﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
//using System.Data.SqlClient;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Vision_about;
using VisionAbout;
using System.Runtime.InteropServices;
using System.Windows.Forms.DataVisualization.Charting;
using System.Threading;
using System.IO.Ports;
using Can_Test.窗体界面;
using System.IO;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using BaseVisual;
using Sys;
using Helper;
using Sunny.UI;
using NModbus.Serial;
using NModbus.Device;
using NModbus;



namespace VisionAbout
{
    // 主窗体类，负责整个测试系统的界面和逻辑控制
    public partial class FrmMain : Form
    {
        // Modbus通信主站对象 - 用于与Modbus从站设备通信
        private static IModbusMaster master;
        // LIN通信状态 - 记录LIN总线通信状态
        int LinState;
        // 模温机连接状态 - 记录模温机设备连接状态
        int MWJ_Connect;


        // 扫码枪相关变量
        private int Scan;              // 扫码状态：0=未扫码，1=正在扫码，2=扫码完成
        private string FL_ID = "/";    // 条码ID - 存储扫描到的条码内容
        private string FL_Name = "/";  // 条码名称 - 条码对应的产品名称
        private string OP_ID;          // 操作员ID - 当前操作员的工号
        private string OP_Name;        // 操作员姓名 - 当前操作员的姓名

        //扫码枪
        private string[] CodeStr = new string[6] { "", "", "", "", "", "" };  // 存储6个工位的条码数据
        bool[] Code_Ok = new bool[6];   // 条码扫描完成状态数组，标记每个工位是否完成扫码


        // 电源控制相关字节数组
        byte[] PowerStr1 = new byte[9] { 0x01, 0x10, 0x00, 0x09, 0x00, 0x05, 0x0A, 0x00, 0x03 };  // 电源控制命令前缀
        byte[] PowerStr2 = new byte[2];      // 电源参数临时存储
        byte[] PowerStr3 = new byte[4] { 0x00, 0x00, 0x42, 0xF0 };   // 电流上限120A的字节表示
        //01 10 00 09 00 05 0A 00 03 00 00 41 40 00 00 42 F0 22 3B 

        private int currentIndex = 0;  // 当前要更新的Label索引，用于循环更新显示

        //01 10 00 0A 00 04 08 00 00 42 70 00 00 41 F0 D0 9F

        // 界面控件数组 - 用于管理6个工位的显示控件
        TextBox[] TB_DS = new TextBox[6];     // 显示状态文本框数组
        TextBox[] TB_Flow = new TextBox[6];   // 流量显示文本框数组
        TextBox[] TB_C = new TextBox[6];      // 电流显示文本框数组
        TextBox[] TB_A = new TextBox[6];      // 电压显示文本框数组
        TextBox[] TB_Power = new TextBox[6];  // 功率显示文本框数组
        TextBox[] TB_INP = new TextBox[6];    // 输入压力显示文本框数组
        TextBox[] TB_OUTP = new TextBox[6];   // 输出压力显示文本框数组
        TextBox[] TB_DiffP = new TextBox[6];  // 压差显示文本框数组


        Chart[] CT = new Chart[6];                    // 图表控件数组，用于显示实时曲线
        CheckBox[] CBox_CT = new CheckBox[6];         // 图表显示复选框数组，控制是否显示图表
        PictureBox[] PB_State = new PictureBox[6];    // 状态指示灯图片框数组


        CheckBox[] CBox_LIN = new CheckBox[6];        // LIN通信复选框数组
        UISwitch[] UIStart = new UISwitch[6];         // 启动开关数组

        // 扫码枪助手 - 用于监听和处理扫码枪输入
        Helper.BarcodeScannerHelper scannerListener = new BarcodeScannerHelper();

        public Image[] images1 = new Image[15];   // 图片资源数组，存储各种状态图片
        BaseClass1 StandardLB = new BaseClass1(); // 标准功能类，包含通用方法和属性


        // 定时器
        private System.Timers.Timer Timer_Auto;   // 自动测试定时器 - 控制自动测试流程
        private System.Timers.Timer Timer_IO;     // IO监控定时器 - 监控输入输出状态
        private System.Timers.Timer Timer_LIN;    // LIN通信定时器 - 处理LIN总线通信

        private string DataTime;   // 数据时间字符串
        private int PowerInt;      // 电源状态


        // 构造函数
        public FrmMain()
        {
            InitializeComponent();  // 初始化窗体组件

            // 手动绑定验证事件
            BindValidationEvents();
            // 注册扫码事件 - 当扫码枪扫描到条码时触发
            scannerListener.ScanerEvent += ScannerListener_ScanerEvent; 

            this.scannerListener.Start(); // 启动扫码监听
        }

        // 扫码事件处理
        private void ScannerListener_ScanerEvent(string codes)
        {


            Scan = 1;                      // 设置扫码状态为正在扫码
            label211.Text = OP_ID;         // 更新操作员ID显示
            FL_Name = "";                  // 清空条码名称

            // 更新操作员姓名显示，使用委托确保线程安全
            UpdateLabel(label215, OP_Name + "", 4);

            label211.Text = OP_ID + codes;         // 显示操作员ID和扫描到的条码
            FL_ID = codes;                         // 保存条码内容
        }


        // 查找ID对应的名称
        public void LoID()
        {
            if (Scan == 1)       // 如果正在扫码状态
            {
                // 在OPID数组中查找条码对应的索引
                int index = Array.IndexOf(StandardLB.SQL1.OPID, FL_ID);
                if (index >= 0)  // 如果找到匹配的条码
                {
                    FL_Name = StandardLB.SQL1.OPName[index];     // 获取对应的产品名称

                    // 更新显示操作员姓名和产品名称
                    UpdateLabel(label215, OP_Name + FL_Name, 4);

                }

                // 如果成功获取到产品名称
                if (FL_Name != "/" && FL_Name != "")
                {
                    Scan = 2;        // 设置扫码状态为完成
                }
            }

            // 如果PLC连接正常，写入扫码状态到PLC
            if (StandardLB.PLCState)
            {
                if (FL_Name != "/" && FL_Name != "")
                {
                    StandardLB.WiterPLCint(4, 1);     // 扫码成功，写入1到PLC
                }
                else
                {
                    StandardLB.WiterPLCint(4, 0);     // 扫码失败，写入0到PLC
                }
            }
        }

        // 窗体加载事件
        private void FrmMain_Load(object sender, EventArgs e)
        {
            MainControl();          // 初始化主控件 - 将界面控件分配到数组
            DataBuffers();          // 初始化数据缓冲区 - 为数据存储分配内存
            StringArraysManager();  // 初始化字符串数组 - 初始化字符串数组

            SQLControlVlalue(4);    // 读取产品配置 - 从数据库或文件加载产品配置
            SQLControlVlalue(3);    // 读取参数配置 - 加载测试参数配置

            TimerIO();              // 启动IO定时器 - 开始监控输入输出
            TimerAuto();            // 启动自动测试定时器 - 开始自动测试流程
            TimerLIN();             // 启动LIN定时器 - 开始LIN总线通信

            //PortOpen();           // 端口打开（注释掉的代码）
            Analog_AD2();           // 初始化模拟量采集 - 设置模拟量采集模块
            Pro_Power1();           // 初始化电源控制 - 设置电源控制模块
            Reader_Code();          // 初始化条码阅读器 - 设置条码扫描器
            Temperature_M1();       // 初始化温度监控 - 设置温度监测模块



            // 初始化所有图表
            for (int i = 0; i < 6; i++)
            {
                ChartSet(CT[i]);     // 设置每个图表的显示属性
            }

            // 管理员权限检查
            if (Login_NoSQL.user_name.Contains("管理员"))
            {
                button27.Enabled = true;   // 启用管理员按钮
                panel2.Visible = true;     // 显示管理员面板
            }

            // 读取操作员和报警信息
            string LINName = @"C:\LK\LIN.txt";
            StandardLB.Lin_Name = File.ReadAllLines(LINName);

            // 读取操作员和报警信息
            string Name1 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "name.txt");
            string ID1 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ID.txt");

            StandardLB.SQL1.OPName = File.ReadAllLines(Name1);   // 加载操作员姓名列表
            StandardLB.SQL1.OPID = File.ReadAllLines(ID1);       // 加载操作员ID列表

            string AM = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Alarm.txt");

            StandardLB.Alarm = File.ReadAllLines(AM);           // 加载报警信息列表


            this.WindowState = FormWindowState.Maximized;       // 最大化窗口
        }

        // 窗体关闭事件
        private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            Software_Close();   // 调用软件关闭处理函数
        }

        // 软件关闭处理
        private void Software_Close()
        {
            // 弹出确认对话框询问用户是否退出
            DialogResult result = MessageBox.Show("是否确认退出", "退出询问", MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
            
            if (result == DialogResult.OK)  // 如果用户确认退出
            {
                // 关闭所有串口
                serialPort1.Close();
                serialPort2.Close();
                serialPort4.Close();

                Environment.Exit(0);  // 退出应用程序
            }
            if (result == DialogResult.Cancel)
            {
                // 用户取消退出
            }

            // 无论如何都关闭串口
            serialPort1.Close();
            serialPort2.Close();
            serialPort4.Close();

        }

        // 发送条码读取命令
        public void ReaderCode(string Str1)
        {
            try
            {
                if (!serialPort5.IsOpen)       // 如果串口未打开
                { 
                    serialPort5.Open();        // 打开串口
                }
                if (Str1.Length > 0)           // 如果有数据要发送
                {
                    byte[] byt = strToToHexByte(Str1);       // 字符串转16进制字节 
                    serialPort5.Write(byt, 0, byt.Length);   // 发送数据
                }

            }
            catch (Exception) { }

        }

        // 初始化条码阅读器
        public void Reader_Code()
        {
            try
            {
                // 配置串口参数
                serialPort5.PortName = "COM11";          // 设置串口号
                serialPort5.BaudRate = 115200;           // 设置波特率
                serialPort5.Parity = Parity.None;        // 设置校验位
                serialPort5.DataBits = 8;                // 设置数据位
                serialPort5.StopBits = StopBits.One;     // 设置停止位
                serialPort5.DataReceived += SerialPort5_DataReceived;  // 注册数据接收事件
                serialPort5.Open();                                    // 打开串口
            }
            catch (Exception) { }
        }

        // 条码阅读器数据接收事件
        private void SerialPort5_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                Thread.Sleep(150);                                   // 短暂延迟确保数据完整接收
                byte[] result = new byte[serialPort5.BytesToRead];   // 创建缓冲区
                int len = serialPort5.BytesToRead;                   // 获取可读字节数
                serialPort5.Read(result, 0, len);                    // 读取数据

                // 将字节数据转换为字符串，并清理格式
                string Str = System.Text.Encoding.Default.GetString(result).Replace("\r", "").Trim();

                if (Str.Length > 2)          // 如果接收到有效数据
                {
                    UpdateLabelText(Str);    // 更新标签文本
                }

            }
            catch (Exception Ex) { }
            serialPort5.DiscardInBuffer();        // 清空输入缓冲区
        }


        // 清空指定工位的条码
        private void CodeClear(int Station)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                Code_Ok[Station] = false;        // 重置完成状态
                CodeStr[Station] = "";           // 清空条码
                UpdateLabel(StandardLB.labelContol[Station], "", 7);  // 更新显示
            });
        }


        // 更新Label文本的方法
        private void UpdateLabelText(string Str)
        {
            this.BeginInvoke((EventHandler)delegate
            {
                // 遍历所有工位标签，找到第一个可用的位置显示条码
                for (int i = 0; i < StandardLB.labelContol.Length; i++)
                {
                    // 如果标签文本长度小于5且复选框被选中
                    if (StandardLB.labelContol[i].Text.Length < 5 && StandardLB.CBox[i].Checked)
                    {
                        StandardLB.labelContol[i].Text = Str;   // 显示条码
                        break;       // 找到位置后退出循环
                    }
                }
            });
        }


        // 模拟量采集数据发送
        public void Analog_AD(string Str1)
        {
            try
            {
                if (!serialPort1.IsOpen)          // 如果串口未打开
                {
                    serialPort1.Open();           // 打开串口
                }
                if (Str1.Length > 0)               // 如果有数据要发送
                {
                    byte[] byt = strToToHexByte(Str1);      // 字符串转16进制字
                    serialPort1.Write(byt, 0, byt.Length);  // 发送数据
                }

            }
            catch (Exception EX) { }
        }

        // 初始化模拟量采集
        public void Analog_AD2()
        {
            try
            {
                // 配置串口参数
                serialPort1.PortName = "COM12";         // 设置串口号
                serialPort1.BaudRate = 9600;            // 设置波特率
                serialPort1.Parity = Parity.None;       // 设置校验位
                serialPort1.DataBits = 8;               // 设置数据位
                serialPort1.StopBits = StopBits.One;    // 设置停止位
                serialPort1.DataReceived += SerialPort1_DataReceived1;  // 注册数据接收事件
                serialPort1.Open();                     // 打开串口
            }
            catch (Exception) { }
        }

        // 模拟量数据接收处理
        private void SerialPort1_DataReceived1(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                Thread.Sleep(150);                  // 短暂延迟确保数据完整接收
                byte[] result = new byte[serialPort1.BytesToRead];  // 创建缓冲区
                int len = serialPort1.BytesToRead;   // 获取可读字节数
                serialPort1.Read(result, 0, len);    // 读取数据 

                // 字节转16进制字符串并清理格式
                string Str0 = byteToHexStr(result).Replace(" ", "").Trim(); 

                if (Str0.Length > 50)      // 如果接收到完整的数据包
                {
                    // 解析输入压力数据（6个通道）
                    // 使用StrSubstring方法从字符串中提取指定位置和长度的数据并转换为数值
                    StandardLB.Input_pressure[0] = (StandardLB.StrSubstring(Str0, 30, 4) * 600) - 100;
                    StandardLB.Input_pressure[1] = (StandardLB.StrSubstring(Str0, 34, 4) * 600) - 100;
                    StandardLB.Input_pressure[2] = (StandardLB.StrSubstring(Str0, 38, 4) * 600) - 102;
                    StandardLB.Input_pressure[3] = (StandardLB.StrSubstring(Str0, 42, 4) * 600) - 100;
                    StandardLB.Input_pressure[4] = (StandardLB.StrSubstring(Str0, 46, 4) * 600) - 100;
                    StandardLB.Input_pressure[5] = (StandardLB.StrSubstring(Str0, 50, 4) * 600) - 100;

                    // 处理输入压力数据，确保负值
                    for (int i = 0; i < 6; i++)
                    {
                        if (StandardLB.Input_pressure[i] >= 0)
                        {
                            StandardLB.Input_pressure[i] = -1;  // 如果为正值则设为-1
                        }
                    }

                    // 解析输出压力数据（6个通道）
                    StandardLB.Output_pressure[0] = StandardLB.StrSubstring(Str0, 54, 4) * 1000;
                    StandardLB.Output_pressure[1] = StandardLB.StrSubstring(Str0, 58, 4) * 1000;
                    StandardLB.Output_pressure[2] = StandardLB.StrSubstring(Str0, 62, 4) * 1000;
                    StandardLB.Output_pressure[3] = StandardLB.StrSubstring(Str0, 66, 4) * 1000;
                    StandardLB.Output_pressure[4] = StandardLB.StrSubstring(Str0, 70, 4) * 1000;
                    StandardLB.Output_pressure[5] = StandardLB.StrSubstring(Str0, 74, 4) * 1000;

                    // 解析电流和流量数据（根据状态决定是否处理）
                    // 每个工位的电流和流量计算都考虑了校准系数
                    if (StandardLB.State[7]) { StandardLB.Current[0] = StandardLB.StrSubstring(Str0, 78, 4) * 46 * StandardLB.Parameterfloat[281]; StandardLB.Flow[0] = StandardLB.StrSubstring(Str0, 6, 4) * 50; } else { StandardLB.Current[0] = 0; StandardLB.Flow[0] = 0; };
                    if (StandardLB.State[8]) { StandardLB.Current[1] = StandardLB.StrSubstring(Str0, 82, 4) * 46 * StandardLB.Parameterfloat[282]; StandardLB.Flow[1] = StandardLB.StrSubstring(Str0, 10, 4) * 50; } else { StandardLB.Current[1] = 0; StandardLB.Flow[1] = 0; };
                    if (StandardLB.State[9]) { StandardLB.Current[2] = StandardLB.StrSubstring(Str0, 86, 4) * 46 * StandardLB.Parameterfloat[283]; StandardLB.Flow[2] = StandardLB.StrSubstring(Str0, 14, 4) * 50; } else { StandardLB.Current[2] = 0; StandardLB.Flow[2] = 0; };
                    if (StandardLB.State[10]) { StandardLB.Current[3] = StandardLB.StrSubstring(Str0, 90, 4) * 46 * StandardLB.Parameterfloat[284]; StandardLB.Flow[3] = StandardLB.StrSubstring(Str0, 18, 4) * 50; } else { StandardLB.Current[3] = 0; StandardLB.Flow[3] = 0; };
                    if (StandardLB.State[11]) { StandardLB.Current[4] = StandardLB.StrSubstring(Str0, 94, 4) * 46 * StandardLB.Parameterfloat[285]; StandardLB.Flow[4] = StandardLB.StrSubstring(Str0, 22, 4) * 50; } else { StandardLB.Current[4] = 0; StandardLB.Flow[4] = 0; };
                    if (StandardLB.State[12]) { StandardLB.Current[5] = StandardLB.StrSubstring(Str0, 98, 4) * 46 * StandardLB.Parameterfloat[286]; StandardLB.Flow[5] = StandardLB.StrSubstring(Str0, 26, 4) * 50; } else { StandardLB.Current[5] = 0; StandardLB.Flow[5] = 0; };

                    // 电压数据（所有通道相同,只读取一个值）
                    StandardLB.Voltage[0] = StandardLB.StrSubstring(Str0, 102, 4) * 60;
                    // 将同一个电压值赋给所有工位
                    StandardLB.Voltage[1] = StandardLB.Voltage[0];
                    StandardLB.Voltage[2] = StandardLB.Voltage[0];
                    StandardLB.Voltage[3] = StandardLB.Voltage[0];
                    StandardLB.Voltage[4] = StandardLB.Voltage[0];
                    StandardLB.Voltage[5] = StandardLB.Voltage[0];

                    // 计算压差和输入功率
                    for (int i = 0; i < 6; i++)
                    {
                        StandardLB.Diff_pressure[i] = StandardLB.Output_pressure[i] - StandardLB.Input_pressure[i];    // 压差=输出压力-输入压力
                        StandardLB.InPower[i] = StandardLB.Current[i] * StandardLB.Voltage[i];  // 功率=电流×电压
                    }

                    // 温度数据
                    StandardLB.Temperature[0] = (StandardLB.StrSubstring(Str0, 106, 4) * 200) - 50;    // 重置连接状态计数器
                    //StandardLB.Box_pressure[0] = StandardLB.StrSubstring(Str0, 110, 4) * 500;

                    StandardLB.ConnectState_Analog = 0;  // 重置连接状态
                }
            }
            catch (Exception EX) { }
            serialPort1.DiscardInBuffer();  // 清空输入缓冲区
        }

        // 报警状态处理
        public void AlarmState0()
        {
            // 急停处理
            if (StandardLB.State[29])//急停
            {

                for (int i = 0; i < 6; i++)
                {
                    StandardLB.AlarmInt[i] = 1;   // 设置所有工位报警
                }

            }

            // 处理每个工位的报警状态
            for (int i = 0; i < 6; i++)
            {
                if (StandardLB.AlarmInt[i] == 0)    // 如果当前工位无报警
                {
                    UpdateTexBox(TB_DS[i], StandardLB.Alarm[0], 1);   // 显示正常状态
                }
                else   // 如果有报警
                {
                    UpdateTexBox(TB_DS[i], StandardLB.Alarm[StandardLB.AlarmInt[i]], 2);    // 显示报警信息
                    UISwitchHandle(i, 0);                                                   // 关闭该工位的开关
                    GetPictures1(PB_State[i], 0);                                           // 显示红色指示灯
                    StandardLB.WiterPLCAlarm(i, (short)StandardLB.AlarmInt[i]);             //发送报警到PLC,传给PLC三色灯报警
                }
                // 复位处理
                if (StandardLB.State[27] && StandardLB.AlarmInt[i] != 0) // 如果复位按钮按下且当前有报警
                {
                    StandardLB.AlarmInt[i] = 0;                          // 清除报警
                    UpdateTexBox(TB_DS[i], StandardLB.Alarm[0], 1);      // 恢复正常显示
                    GetPictures1(PB_State[i], 2);                        // 显示灰色指示灯
                    StandardLB.WiterPLCAlarm(i, 0);                      // 清除PLC报警
                }

                // 主罐液位过低报警
                if (StandardLB.State[28])         // 如果主罐液位过低
                {
                    StandardLB.AlarmInt[i] = 2;   // 设置报警状态为2（液位过低）
                }
            }
        }


        // 具体报警条件检查 - 检查单个工位的具体报警条件
        public void AlarmState1(int Station)
        {

            // 电流下限报警
            if (StandardLB.Current[Station] < StandardLB.CurrentDown[Station])
            {
                StandardLB.AlarmInt[Station] = 4;//电流下限报警
            }
            // 电流上限报警
            if (StandardLB.Current[Station] > StandardLB.CurrentUP[Station])
            {
                StandardLB.AlarmInt[Station] = 5;//电流上限报警
            }

            // 电压下限报警
            if (StandardLB.Voltage[Station] < StandardLB.VoltageDown[Station])
            {
                StandardLB.AlarmInt[Station] = 6;//电压下限报警
            }
            // 电压上限报警
            if (StandardLB.Voltage[Station] > StandardLB.VoltageUP[Station])
            {
                StandardLB.AlarmInt[Station] = 7;//电压上限报警
            }

            // 功率下限报警
            if (StandardLB.InPower[Station] < StandardLB.InPowerDown[Station])
            {
                StandardLB.AlarmInt[Station] = 8;//功率下限报警
            }
            // 功率上限报警
            if (StandardLB.InPower[Station] > StandardLB.InPowerUp[Station])
            {
                StandardLB.AlarmInt[Station] = 9;//功率上限报警
            }

            // 流量下限报警
            if (StandardLB.Flow[Station] < StandardLB.FlowDown[Station])
            {
                StandardLB.AlarmInt[Station] = 10;//流量下限报警
            }
            // 流量上限报警
            if (StandardLB.Flow[Station] > StandardLB.FlowUP[Station])
            {
                StandardLB.AlarmInt[Station] = 11;//流量上限报警
            }

            // 出口压力下限报警
            if (StandardLB.Output_pressure[Station] < StandardLB.OutpressureDown[Station])
            {
                StandardLB.AlarmInt[Station] = 12;//出口压力下限报警
            }
            // 出口压力上限报警
            if (StandardLB.Output_pressure[Station] > StandardLB.OutpressureUp[Station])
            {
                StandardLB.AlarmInt[Station] = 13;//出口压力上限报警
            }

            // 入口压力处理 - 确保入口压力为负值
            for (int i = 0; i < 6; i++)
            {
                if (StandardLB.Input_pressure[i] >= 0)
                {
                    StandardLB.Input_pressure[i] = -1;   // 如果为正值则设为-1
                }
            }

            // 入口压力下限报警
            if (StandardLB.Input_pressure[Station] < StandardLB.InputpressureDown[Station])
            {
                StandardLB.AlarmInt[Station] = 14;  //入口压力下限报警
            }
            // 入口压力上限报警
            if (StandardLB.Input_pressure[Station] > StandardLB.InputpressureUp[Station])
            {
                StandardLB.AlarmInt[Station] = 15;  //入口压力上限报警
            }
        }



        // 电源控制发送
        public void ProPower1(string Str1)
        {
            try
            {
                bool isOpen = serialPort2.IsOpen;

                if (!isOpen)
                {
                    serialPort2.Open();    // 打开串口
                }

                if (Str1.Length > 0)       //16进制发送
                {
                    byte[] byt = strToToHexByte(Str1);
                    serialPort2.Write(byt, 0, byt.Length);   // 发送数据
                }
            }
            catch (Exception) { }
        }

        // 初始化电源控制
        public void Pro_Power1()
        {
            try
            {
                // 配置串口参数
                serialPort2.PortName = "COM7";
                serialPort2.BaudRate = 9600;
                serialPort2.Parity = Parity.None;
                serialPort2.DataBits = 8;
                serialPort2.StopBits = StopBits.One;
                serialPort2.DataReceived += SerialPort2_DataReceived;  // 注册数据接收事件
                serialPort2.Open();                                    // 打开串口
            }
            catch (Exception ex){}
        }


        // 电源控制数据接收（当前为空实现）
        private void SerialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {

        }

        // 电源字符串转换和处理
        private void PowerStrTr(int Idex, string Str)
        {
            try
            {
                float f = float.Parse(Str);                    // 解析浮点数
                PowerStr2 = BitConverter.GetBytes(f);          // 转换为字节数组
                byte[] FZ = new byte[4] { 0x00, 0x00, PowerStr2[3], PowerStr2[2] };// 重新排列字节
                byte[] C = PowerStr1.Concat(FZ).ToArray();     // 拼接数组
                byte[] D = C.Concat(PowerStr3).ToArray();      // 继续拼接
                byte[] E = StandardLB.ToModbus(D);             // Modbus CRC校验
                byte[] F = D.Concat(E).ToArray();              // 最终数据包
                string ABC = StandardLB.byteToHexStr(F);       // 转换为16进制字符串

                if (Idex == 1)
                {
                    ProPower1(ABC);   // 发送电源控制命令
                }
            }
            catch (Exception ex) { }
        }


        // 温度监控数据发送
        public void Temperature_M(string Str1)
        {
            try
            {
                bool isOpen = serialPort4.IsOpen;

                if (!isOpen)
                {
                    serialPort4.Open(); // 打开串口
                }

                if (Str1.Length > 0)    //16进制发送
                {
                    byte[] byt = strToToHexByte(Str1);
                    serialPort4.Write(byt, 0, byt.Length);  // 发送数据
                }
            }
            catch (Exception) { }
        }

        // 初始化温度监控
        public void Temperature_M1()
        {
            try
            {
                // 配置串口参数
                serialPort4.PortName = "COM8";
                serialPort4.BaudRate = 9600;
                serialPort4.Parity = Parity.None;
                serialPort4.DataBits = 8;
                serialPort4.StopBits = StopBits.One;
                // serialPort4.DataReceived += SerialPort4_DataReceived;
                serialPort4.ReadTimeout = 1000;  // 1秒读超时
                serialPort4.WriteTimeout = 1000; // 1秒写超时

                serialPort4.Open();              // 打开串口

                // 创建Modbus主站
                var factory = new ModbusFactory();
                master = factory.CreateRtuMaster(serialPort4);
            }
            catch (Exception ex){}
        }

        private void SerialPort4_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {

            }
            catch (Exception ex) { }
        }


        // LIN通信定时器初始化
        public void TimerLIN()
        {
            Timer_LIN = new System.Timers.Timer(120);   // 120ms间隔
            Timer_LIN.Elapsed += Timer_LIN_Elapsed; ;   
            Timer_LIN.AutoReset = true;                 // 自动重复
            Timer_LIN.Enabled = true;                   // 启用定时器

        }

        // LIN通信定时器事件
        private void Timer_LIN_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Timer_LIN.Stop();   // 暂停定时器

            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();      // 开始计时


                if (StandardLB.RecipeParameter[360] == "1")
                {
                    for (int i = 0; i < 6; i++)
                    {
                        int Idex;
                        int DevHand;

                        // 检查LIN通信使能
                        if (i % 2 == 0)
                        {
                            Idex = 0;
                        }
                        else
                        {
                            Idex = 1;
                        }
                        DevHand = i / 2;

                        // 检查工位使能状态
                        if (StandardLB.State[7 + i])
                        {
                            try
                            {
                                // 发送LIN数据
                                StandardLB.Send_Lin(DevHand, Idex, BaseClass1.DataBuffersArrayLIN[i], StandardLB.ID0[0]);
                                // 读取LIN响应
                                BaseClass1.LINRArrays[i] = StandardLB.Read_Lin(DevHand, Idex, StandardLB.ID0[1]);

                                // 格式化发送数据字符串
                                string[] Str1 = new string[8];
                                StandardLB.LIN_SendStr[i] = "";
                                for (int j = 0; j < BaseClass1.DataBuffersArrayLIN[i].Length; j++)
                                {
                                    Str1[j] = BaseClass1.DataBuffersArrayLIN[i][j].ToString("X2");
                                    StandardLB.LIN_SendStr[i] = StandardLB.LIN_SendStr[i] + " " + Str1[j];
                                }
                                // 更新列表显示
                                UpdatelistBox1(CBox_LIN[i], StandardLB.LIN_SendStr[i], BaseClass1.LINRArrays[i][8]);
                            }
                            catch (Exception ex) { }
                        }

                    }
                }

                sw.Stop();           // 停止计时
                TimeSpan ts2 = sw.Elapsed;
                UpdateTexBox(textBox98, ts2.TotalMilliseconds.ToString(), 5); // 显示执行时间 
            }
            catch (Exception ex) { }

            Timer_LIN.Start();  // 重新启动定时器
        }



        // 自动测试定时器初始化
        public void TimerAuto()
        {
            Timer_Auto = new System.Timers.Timer(1000);  // 创建1秒间隔的定时器
            Timer_Auto.Elapsed += Timer_Auto_Elapsed;    // 注册定时器事件
            Timer_Auto.AutoReset = true;                 // 设置自动重复
            Timer_Auto.Enabled = true;                    // 启用定时器
        }

        // 自动测试定时器事件
        private void Timer_Auto_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Timer_Auto.Stop();    // 暂停定时器以确保处理完成前不会再次触发
            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();       // 开始计时，用于性能监控

                if (StandardLB.PLCState)    // 如果PLC连接正常
                {
                    StandardLB.WiterPLC();  // 写入数据到PLC

                    // 执行6个工位的自动测试
                    // 每个工位调用Auto方法，传入工位号、测试模式、步骤、状态数组引用和显示控件
                    Auto(0, StandardLB.TsetMode[0], StandardLB.Step[0], ref StandardLB.ZJbool0, textBox180, PB_State[0], textBox121);
                    Auto(1, StandardLB.TsetMode[1], StandardLB.Step[1], ref StandardLB.ZJbool1, textBox29, PB_State[1], textBox219);
                    Auto(2, StandardLB.TsetMode[2], StandardLB.Step[2], ref StandardLB.ZJbool2, textBox58, PB_State[2], textBox222);
                    Auto(3, StandardLB.TsetMode[3], StandardLB.Step[3], ref StandardLB.ZJbool3, textBox68, PB_State[3], textBox227);
                    Auto(4, StandardLB.TsetMode[4], StandardLB.Step[4], ref StandardLB.ZJbool4, textBox76, PB_State[4], textBox235);
                    Auto(5, StandardLB.TsetMode[5], StandardLB.Step[5], ref StandardLB.ZJbool5, textBox87, PB_State[5], textBox238);

                }
                sw.Stop();                    // 停止计时
                TimeSpan ts2 = sw.Elapsed;
                UpdateTexBox(textBox113, ts2.TotalMilliseconds.ToString(), 5);   // 显示执行时间
            }
            catch (Exception EX) { }
            Timer_Auto.Start();             // 重新启动定时器
        }


        // 自动测试逻辑
        public void Auto(int Station, int TestMode, int Step, ref int[] ZJB, TextBox TB, PictureBox PB, TextBox TB_Count)
        {
            switch (Step)
            {
                case 0:      // 初始状态
                    Array.Clear(ZJB, 0, ZJB.Length);     // 清空状态数组
                    StandardLB.PathStr[Station] = "";    // 清空文件路径
                    UISwitchHandle(Station, 1);          // 处理开关状态
                    break;

                case 5:    // 耐久测试
                    string Time0 = DateTime.Now.ToLocalTime().ToString("yyyyMMdd_HHmmss"); 
                    string Time1 = DateTime.Now.ToLocalTime().ToString("G");               
                    if (ZJB[0] == 0)          // 第一次进入步骤5
                    {
                        GetPictures1(PB, 3);  // 显示黄色指示灯（准备状态）

                        // 创建数据保存文件
                        string Na2 = StandardLB.DataSave(StandardLB.SavePT[TestMode]);       // 获取保存路径
                        string[] paths = { Na2, Time0 + "-工位" + (Station + 1) + ".txt" };  // 构建完整文件路径

                        StandardLB.PathStr[Station] = Path.Combine(paths);                   // 组合路径


                        // 创建数据文件表头
                        string T0 = "日期(Date),工位(Station),条码(Barcode),电压(Voltage)(V),电流(Current)(A),压差(Differential Pressure)(Kpa),入口压力(Input Pressure)(Kpa),介质温度(Medium temperature)(°C),输入功率(Input power)(W),流量(Flow)(L/min),发送LIN , 接收LIN";
                        StandardLB.TxtData(StandardLB.PathStr[Station], T0, true);    // 写入表头


                        BaseClass1.StartTime[Station] = DateTime.Now;           // 记录开始时间
                        BaseClass1.StartTime0[Station] = DateTime.Now;          // 记录耐久测试开始时间

                        GetPictures1(PB, 3);      // 显示黄色指示灯

                        UpdateChart(0, Station, CT[Station], CBox_CT[Station]); // 初始化图表
                        ZJB[0] += 1;              // 增加步骤计数器

                    }
                    // 检查温度参数是否完整
                    if (ZJB[0] == 0 && !CheckTemperatureParameters())
                    {
                        MessageBox.Show("温度控制参数不完整，请检查所有温度段设置!", "参数错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        GetPictures1(PB, 0); // 显示红色指示灯
                        break;
                    }
                    // 处理输入压力数据，确保为负值
                    if (StandardLB.Input_pressure[Station] >= 0)
                    {
                        StandardLB.Input_pressure[Station] = -1;
                    }


                    if (ZJB[0] > 0)  // 如果已经初始化完成
                    {
                        // 计算运行时间
                        BaseClass1.difference[Station] = DateTime.Now - BaseClass1.StartTime[Station];

                        UpdateTexBox(TB, BaseClass1.difference[Station].ToString(@"dd\.hh\:mm\:ss"), 5);  // 更新运行时间显示

                        // 准备数据行
                        string Data0 = Time1 + "," + ("工位" + (Station + 1)) + "," + CodeStr[Station] + "," + StandardLB.Voltage[Station].ToString("0.0") + "," + StandardLB.Current[Station].ToString("0.0") + "," +
                        StandardLB.Diff_pressure[Station].ToString("0.0") + "," + StandardLB.Input_pressure[0].ToString("0.0") + "," +
                        StandardLB.Temperature[0].ToString("0.0") + "," + StandardLB.InPower[Station].ToString("0.0") + "," + StandardLB.Flow[Station].ToString("0.0") + "," + StandardLB.LIN_SendStr[Station] + "," + BaseClass1.LINRArrays[Station][8];


                        StandardLB.TxtData(StandardLB.PathStr[Station], Data0, true);    // 写入数据到文件
                        UpdateChart(1, Station, CT[Station], CBox_CT[Station]);          // 更新图表显示
                    }


                    // 设置转速 - 根据参数计算转速百分比
                    StandardLB.LIN_DataBufferSet(Station, 4, 100 * StandardLB.Parameterfloat[100 + Station] / StandardLB.Parameterfloat[280]);


                    // 根据测试模式执行不同逻辑
                    if (TestMode == 0)     // 耐久测试模式
                    {
                        if (ZJB[9] == 0)   // 第一次进入耐久测试
                        {
                            BaseClass1.StartTime0[Station] = DateTime.Now;   // 记录开始时间
                            ZJB[9] = 1;    // 设置标志位
                        }

                        // 计算当前段运行时间
                        BaseClass1.difference0[Station] = DateTime.Now - BaseClass1.StartTime0[Station];   // 计算持续时间

                        // 计算当前总运行时间（用于判断温度段）
                        TimeSpan totalRunTime = DateTime.Now - BaseClass1.StartTime[Station];
                        double totalSeconds = totalRunTime.TotalSeconds;


                        // 检查是否完成一个完整周期（20段温度时间）
                        if (totalSeconds >= StandardLB.Temperature_Time[19])
                        {
                            // 完成一个完整周期，增加循环计数
                            ZJB[11] += 1;

                            // 重置开始时间，开始新的周期
                            BaseClass1.StartTime[Station] = DateTime.Now;

                            // 检查循环次数是否达到设定值
                            if (ZJB[11] >= StandardLB.Parameterfloat[362])
                            {
                                // 达到设定循环次数，完成测试
                                GetPictures1(PB, 1);          // 显示绿色指示灯（完成状态）
                                CodeClear(Station);           // 清空条码
                                StandardLB.WiterPLCcomplete(Station, 10);   // 写入测试完成状态到PLC

                                // 停止该工位的测试
                                UISwitchHandle(Station, 0);   // 关闭开关
                                break;                        // 跳出switch case
                            }
                            else
                            {
                                // 未达到设定次数，继续下一个循环
                                UpdatelistBox0($"工位{Station + 1} 完成第{ZJB[11]}个循环，总共需要{StandardLB.Parameterfloat[362]}个循环");
                            }
                        }



                        StandardLB.WiterStart_Stop(Station, (short)1);   // 启动设备



                        // 检查测试时间是否达到设定值
                        if (BaseClass1.difference0[Station].TotalSeconds > StandardLB.Temperature_Time[19])
                        {
                            BaseClass1.StartTime0[Station] = DateTime.Now;   // 重置开始时间
                            ZJB[11] += 1;      // 增加循环计数
                        }

                        // 检查循环次数是否达到设定值
                        if (ZJB[11] >= StandardLB.Parameterfloat[362])
                        {
                            GetPictures1(PB, 1);          // 显示绿色指示灯（完成状态）
                            CodeClear(Station);           // 清空条码
                            StandardLB.WiterPLCcomplete(Station, 10);   // 写入测试完成状态到PLC
                        }
                        UpdateTexBox(TB_Count, ZJB[11].ToString() + "/" + StandardLB.Parameterfloat[362].ToString(), 5);  // 更新计数显示
                    }


                    // 其他测试模式（启停模式1、2、3）的处理逻辑类似...
                    else if (TestMode == 1)     // 启停模式1
                    {
                        if (ZJB[10] == 0)
                        {
                            BaseClass1.StartTime1[Station] = DateTime.Now;
                            ZJB[10] = 1;
                        }
                        BaseClass1.difference1[Station] = DateTime.Now - BaseClass1.StartTime1[Station];

                        if (BaseClass1.difference1[Station].TotalSeconds < StandardLB.Parameterfloat[71])
                        {
                            StandardLB.WiterStart_Stop(Station, (short)1);
                        }
                        else if (BaseClass1.difference1[Station].TotalSeconds > StandardLB.Parameterfloat[71] && BaseClass1.difference1[Station].TotalSeconds <= StandardLB.cycle0)
                        {
                            StandardLB.WiterStart_Stop(Station, (short)0);
                        }
                        else
                        {
                            BaseClass1.StartTime1[Station] = DateTime.Now;
                            ZJB[12] += 1;
                        }


                        if (ZJB[12] >= StandardLB.Parameterfloat[73])
                        {
                            GetPictures1(PB, 1);
                            CodeClear(Station);
                            StandardLB.WiterPLCcomplete(Station, 10);
                        }

                    }
                    else if (TestMode == 2)   // 启停模式2
                    {


                        if (ZJB[20] == 0)
                        {
                            BaseClass1.StartTime2[Station] = DateTime.Now;
                            ZJB[20] = 1;
                        }
                        BaseClass1.difference2[Station] = DateTime.Now - BaseClass1.StartTime2[Station];

                        if (BaseClass1.difference2[Station].TotalSeconds <= StandardLB.Parameterfloat[81])
                        {
                            StandardLB.WiterStart_Stop(Station, (short)1);
                        }
                        else if (BaseClass1.difference2[Station].TotalSeconds > StandardLB.Parameterfloat[81] && BaseClass1.difference2[Station].TotalSeconds <= StandardLB.cycle1)
                        {
                            StandardLB.WiterStart_Stop(Station, (short)0);
                        }
                        else
                        {
                            BaseClass1.StartTime2[Station] = DateTime.Now;
                            ZJB[22] += 1;

                        }
                        if (ZJB[22] >= StandardLB.Parameterfloat[83])
                        {
                            GetPictures1(PB, 1);
                            CodeClear(Station);
                            StandardLB.WiterPLCcomplete(Station, 10);
                        }


                    }
                    else if (TestMode == 3)   // 启停模式3
                    {
                        if (ZJB[30] == 0)
                        {
                            BaseClass1.StartTime3[Station] = DateTime.Now;
                            ZJB[30] = 1;
                        }
                        BaseClass1.difference3[Station] = DateTime.Now - BaseClass1.StartTime3[Station];


                        if (BaseClass1.difference3[Station].TotalSeconds <= StandardLB.Parameterfloat[91])
                        {
                            StandardLB.WiterStart_Stop(Station, (short)1);
                        }
                        else if (BaseClass1.difference3[Station].TotalSeconds > StandardLB.Parameterfloat[91] && BaseClass1.difference3[Station].TotalSeconds <= StandardLB.cycle2)
                        {
                            StandardLB.WiterStart_Stop(Station, (short)0);
                        }
                        else
                        {
                            BaseClass1.StartTime3[Station] = DateTime.Now;
                            ZJB[32] += 1;

                        }

                        if (ZJB[32] >= StandardLB.Parameterfloat[93])
                        {
                            GetPictures1(PB, 1);
                            CodeClear(Station);
                            StandardLB.WiterPLCcomplete(Station, 10);
                        }

                    }

                    UISwitchHandle(Station, 2);    // 处理开关状态

                    // 延时报警检查
                    if (StandardLB.State[7 + Station])   // 如果工位启用
                    {
                        ZJB[40] += 1;         // 增加运行计时
                    }
                    else
                    {
                        ZJB[40] = 0;          // 重置计时
                    }

                    // 如果运行时间超过设定值，触发报警
                    if (ZJB[40] > StandardLB.Parameterfloat[139])
                    {
                        AlarmState1(Station);  // 触发报警检查
                    }
                    break;

                case 10:    // 完成状态
                    UISwitchHandle(Station, 0);                // 关闭开关
                    StandardLB.WiterPLCcomplete(Station, 15);  // 写入完成状态到PLC
                    break;
            }
        }


        // IO监控定时器初始化
        public void TimerIO()
        {
            Timer_IO = new System.Timers.Timer(1000);   // 创建1秒间隔的定时器
            Timer_IO.Elapsed += Timer_IO_Elapsed; ;     // 注册定时器事件
            Timer_IO.AutoReset = true;                  // 设置自动重复
            Timer_IO.Enabled = true;                    // 启用定时器
        }

        // IO监控定时器事件
        private void Timer_IO_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Timer_IO.Stop();  // 暂停定时器

            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();   // 开始计时

                // PLC连接检查
                if (!StandardLB.PLCState)   // 如果PLC未连接
                {
                    StandardLB.PlcOpen();   // 尝试打开PLC连接
                }

                StandardLB.ConnectState_Analog += 1;  // 更新连接状态计数
                Analog_AD(StandardLB.AnalogSend);     // 发送模拟量采集命令
                LoID();                               // 发送模拟量采集命令// 处理条码识别


                // 温度设定逻辑（根据运行时间分段设定温度）
                // 根据累计运行时间在不同阶段设置不同的目标温度
                double maxTotalMinutes = BaseClass1.difference.Select(ts => ts.TotalSeconds).Max();

                // 20段温度控制逻辑
                bool temperatureSet = false;
                for (int segment = 0; segment < 20; segment++)
                {
                    if (maxTotalMinutes < StandardLB.Temperature_Time[segment])
                    {
                        StandardLB.Set_Temperature = StandardLB.Parameterfloat[300 + segment];
                        temperatureSet = true;

                        // 获取当前温度
                        float currentTemp = StandardLB.Temperature[0];
                        float targetTemp = StandardLB.Set_Temperature;
                        float segmentTime = StandardLB.Parameterfloat[340 + segment]; // 小时

                        // 检查是否为空值
                        if (string.IsNullOrEmpty(StandardLB.RecipeParameter[300 + segment]) ||
                            string.IsNullOrEmpty(StandardLB.RecipeParameter[340 + segment]))
                        {
                            MessageBox.Show($"第{segment + 1}段温度或时间参数未设置!", "参数错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                            break;
                        }

                        // 温度控制逻辑
                        if (StandardLB.RecipeParameter[361] == "1") // 启动控温
                        {
                            if (segmentTime > 0) // 时间不为0才处理
                            {
                                // 判断是升温还是降温
                                if (currentTemp < targetTemp)
                                {
                                    // 升温处理 - 直接发送目标温度给PLC
                                    SendTemperatureToPLC(targetTemp, segmentTime);
                                }
                                else if (currentTemp > targetTemp)
                                {
                                    // 降温处理 - 计算斜率并发送给模温机
                                    float tempDifference = currentTemp - targetTemp;
                                    float slope = tempDifference / segmentTime; // 温度变化率 °C/小时
                                    SendCoolingSlopeToTemperatureController(slope, targetTemp, segmentTime);
                                }
                                // 如果当前温度等于目标温度，不需要调整
                            }
                        }
                        break;
                    }
                }

                // 如果超过所有段的时间，使用最后一段的温度
                if (!temperatureSet)
                {
                    StandardLB.Set_Temperature = StandardLB.Parameterfloat[319];
                }



                if (StandardLB.PLCState)   // 如果PLC连接正常
                {
                    StandardLB.ReadPLC();  // 读取PLC数据

                    AlarmState0();         // 处理报警状态 

                    Man_WiterPLCBool();    // 手动写入PLC布尔量

                    // 更新6个工位的显示数据
                    for (int i = 0; i < 6; i++)
                    {
                        // 处理输入压力数据
                        if (StandardLB.Input_pressure[i] >= 0)
                        {
                            StandardLB.Input_pressure[i] = -1;
                        }

                        // 更新各种参数的显示
                        UpdateTexBox(TB_C[i], StandardLB.Voltage[i].ToString("0.0") + "V", 5);
                        UpdateTexBox(TB_A[i], StandardLB.Current[i].ToString("0.0") + "A", 5);
                        UpdateTexBox(TB_Power[i], StandardLB.InPower[i].ToString("0.0") + "W", 5);
                        UpdateTexBox(TB_INP[i], StandardLB.Input_pressure[i].ToString("0.0") + "kPa", 5);
                        UpdateTexBox(TB_OUTP[i], StandardLB.Output_pressure[i].ToString("0.0") + "kPa", 5);
                        UpdateTexBox(TB_DiffP[i], StandardLB.Diff_pressure[i].ToString("0.0") + "kPa", 5);
                        UpdateTexBox(TB_Flow[i], StandardLB.Flow[i].ToString("0.0") + "L/min", 5);
                    }

                    // 更新温度显示
                    UpdateTexBox(textBox96, StandardLB.Temperature[0].ToString("0.0") + "°C", 5);//罐体温度1

                   // UpdatePic();  // 更新图片显示
                    Map();        // 更新地图显示
                }

                // 清空未选中工位的条码
                for (int i = 0; i < 6; i++)
                {
                    if (!StandardLB.CBox[i].Checked)
                    {
                        CodeClear(i);
                    }
                }


                // LIN通信处理
                if (StandardLB.RecipeParameter[360] == "1")
                {
                    if (LinState == 0 && StandardLB.LINState[9] != "1")
                    {
                        StandardLB.Open_Init_Lin();    // 初始化LIN通信

                    }
                    else if (LinState == 0 && StandardLB.LINState[9] == "1")
                    {
                        LinState = 1;                // 设置LIN状态
                        // 更新LIN状态显示
                        UpdatelistBox0(StandardLB.LINState[0]);
                        UpdatelistBox0(StandardLB.LINState[1]);
                        UpdatelistBox0(StandardLB.LINState[2]);
                    }
                }

                // 模温机数据处理
                try
                {
                    if (BaseClass1._isConnected)
                    {
                        // 读取模温机寄存器数据
                        StandardLB.MWJ_Data = BaseClass1.ReadRegisters(0, 70);

                        // 解析各种数据
                        float D1 = StandardLB.MWJ_Data[0] / 100;
                        float D2 = StandardLB.MWJ_Data[1] / 100;
                        float D3 = StandardLB.MWJ_Data[2] / 100;
                        float D4 = StandardLB.MWJ_Data[3] / 100;
                        float D5 = StandardLB.MWJ_Data[4] / 100;
                        float D6 = StandardLB.MWJ_Data[5];
                        float D7 = StandardLB.MWJ_Data[6] / 100;

                        // 更新模温机数据显示
                        UpdateTexBox(textBox239, D1.ToString("F1")+ "℃", 5);
                        UpdateTexBox(textBox240, D2.ToString("F1") + "℃", 5);
                        UpdateTexBox(textBox242, D3.ToString("F1") + "℃", 5);
                        UpdateTexBox(textBox241, D4.ToString("F1") + "Bar", 5);
                        UpdateTexBox(textBox246, D5.ToString("F1") + "Bar", 5);
                        UpdateTexBox(textBox245, D6.ToString("F1") + "%", 5);
                        UpdateTexBox(textBox244, D7.ToString("F1") + "℃", 5);
                    }

                    MWJ_Connect += 1;      // 增加连接计数
                    if (MWJ_Connect<5)
                    {
                        if (BaseClass1.CheckConnection())
                        {
                            // 检查模温机连接状态
                            UpdateLabel(label293, "模温机连接状态：已连接", 1);
                        }
                        else
                        {
                            BaseClass1.Connect();     // 尝试连接
                            UpdateLabel(label293, "模温机连接状态：连接中", 2);
                        }
                    }
                    else if(MWJ_Connect>10)
                    {
                        MWJ_Connect = 0;    // 重置连接计数
                    }
                }
                catch (Exception ex) { }

                // 温度控制逻辑
                try
                {
                    if (StandardLB.RecipeParameter[361] == "1")
                    {
                        float Set_T;
                        if (StandardLB.Set_Temperature > 20)
                        {
                            Set_T = 20;
                        }
                        else
                        {
                            Set_T = StandardLB.Set_Temperature;
                        }
                        ushort SetT = (ushort)(Set_T * 100);
                    }
                }
                catch (Exception ex) { }

                // 更新状态显示
                UpdateTexBox(textBox204, StandardLB.ConnectState_Analog.ToString(), 5);

                sw.Stop();                   // 停止计时
                TimeSpan ts2 = sw.Elapsed;
                UpdateTexBox(textBox115, ts2.TotalMilliseconds.ToString(), 5);// 显示执行时间
            }
            catch (Exception ex) { }

            Timer_IO.Start(); // 重新启动定时器
        }



        // 发送温度设定到PLC
        private void SendTemperatureToPLC(float targetTemperature, float timeHours)
        {
            try
            {
                // 根据您的PLC通信协议实现温度设定
                // 这里需要根据实际的通信协议来编写
                // 示例：StandardLB.WiterPLCTemperature(targetTemperature, timeHours);

                // 记录日志
                UpdatelistBox0($"发送升温指令: 目标温度{targetTemperature}°C, 时间{timeHours}小时");
            }
            catch (Exception ex)
            {
                UpdatelistBox0($"发送升温指令失败: {ex.Message}");
            }
        }

        // 发送降温斜率到模温机
        private void SendCoolingSlopeToTemperatureController(float slope, float targetTemperature, float timeHours)
        {
            try
            {
                // 根据模温机的通信协议实现降温斜率设定
                // 这里需要根据实际的通信协议来编写
                // 示例：StandardLB.SendCoolingSlope(slope, targetTemperature, timeHours);

                // 记录日志
                UpdatelistBox0($"发送降温斜率: 斜率{slope:F2}°C/小时, 目标温度{targetTemperature}°C, 时间{timeHours}小时");
            }
            catch (Exception ex)
            {
                UpdatelistBox0($"发送降温指令失败: {ex.Message}");
            }
        }

        // 检查温度参数是否完整
        private bool CheckTemperatureParameters()
        {
            for (int i = 0; i < 20; i++)
            {
                if (string.IsNullOrEmpty(StandardLB.RecipeParameter[300 + i]) ||
                    string.IsNullOrEmpty(StandardLB.RecipeParameter[340 + i]))
                {
                    return false;
                }
            }
            return true;
        }

        // 创建新配方
        public void NewRecipe()
        {
            string[] filePaths = Directory.GetFiles(StandardLB.RecipePath);
            string[] Nmae = new string[filePaths.Length];
            for (int i = 0; i < filePaths.Length; i++)
            {
                Nmae[i] = Path.GetFileNameWithoutExtension(filePaths[i]);
            }
            bool Already_contained = Nmae.Contains(textBox1.Text.Trim());


            if (Already_contained)
            {

                MessageBox.Show("产品配方名称重复", "提示信息", MessageBoxButtons.YesNo);
            }
            else if (!Already_contained)
            {
                if (textBox1.Text.Length > 0)
                {
                    SQLControlVlalue(1);     // 添加配方
                    textBox1.Text = "";
                    MessageBox.Show("产品配方添加成功", "提示信息", MessageBoxButtons.YesNo);
                }
                else
                {
                    MessageBox.Show("产品配方异常，请重新输入", "提示信息", MessageBoxButtons.YesNo);
                }
            }
        }

        // SQL控制值处理
        private void SQLControlVlalue(int Idex)
        {
            if (Idex == 1)  //添加配方参数
            {
                string[] str = new string[400];
                string Str0 = "";
                str[0] = textBox1.Text.Trim();

                str[10] = comboBox8.Text;
                str[11] = comboBox4.Text;
                str[12] = comboBox5.Text;
                str[13] = comboBox3.Text;
                str[14] = comboBox7.Text;
                str[15] = comboBox6.Text;

                str[30] = textBox114.Text.Trim();
                str[31] = textBox112.Text.Trim();
                str[32] = textBox111.Text.Trim();
                str[33] = textBox110.Text.Trim();
                str[34] = textBox109.Text.Trim();
                str[35] = textBox108.Text.Trim();

                str[50] = textBox107.Text.Trim();
                str[51] = textBox106.Text.Trim();
                str[52] = textBox105.Text.Trim();
                str[53] = textBox104.Text.Trim();
                str[54] = textBox103.Text.Trim();
                str[55] = textBox102.Text.Trim();

                str[64] = textBox216.Text.Trim();//下限
                str[65] = textBox217.Text.Trim();//上限

                str[71] = textBox19.Text.Trim();
                str[72] = textBox33.Text.Trim();
                str[73] = textBox50.Text.Trim();

                str[81] = textBox52.Text.Trim();
                str[82] = textBox55.Text.Trim();
                str[83] = textBox101.Text.Trim();

                str[91] = textBox56.Text.Trim();
                str[92] = textBox53.Text.Trim();
                str[93] = textBox51.Text.Trim();

                str[100] = textBox203.Text.Trim();//转速
                str[101] = textBox195.Text.Trim();
                str[102] = textBox194.Text.Trim();
                str[103] = textBox193.Text.Trim();
                str[104] = textBox192.Text.Trim();
                str[105] = textBox191.Text.Trim();


                str[139] = textBox49.Text;

                str[140] = textBox18.Text;//OP1电流下限
                str[141] = textBox15.Text;
                str[142] = textBox13.Text;
                str[143] = textBox25.Text;
                str[144] = textBox27.Text;
                str[145] = textBox137.Text;

                str[146] = textBox16.Text;//OP1电流上限
                str[147] = textBox2.Text;
                str[148] = textBox21.Text;
                str[149] = textBox20.Text;
                str[150] = textBox26.Text;
                str[151] = textBox136.Text;

                str[152] = textBox146.Text;//OP1电压下限
                str[153] = textBox148.Text;
                str[154] = textBox149.Text;
                str[155] = textBox143.Text;
                str[156] = textBox141.Text;
                str[157] = textBox139.Text;

                str[158] = textBox145.Text;//OP1电压上限
                str[159] = textBox147.Text;
                str[160] = textBox144.Text;
                str[161] = textBox142.Text;
                str[162] = textBox140.Text;
                str[163] = textBox138.Text;

                str[164] = textBox158.Text;//OP1功率下限
                str[165] = textBox161.Text;
                str[166] = textBox162.Text;
                str[167] = textBox155.Text;
                str[168] = textBox153.Text;
                str[169] = textBox151.Text;


                str[170] = textBox157.Text;//OP1功率上限
                str[171] = textBox160.Text;
                str[172] = textBox156.Text;
                str[173] = textBox154.Text;
                str[174] = textBox152.Text;
                str[175] = textBox150.Text;

                str[176] = textBox171.Text;//OP1流量下限
                str[177] = textBox173.Text;
                str[178] = textBox174.Text;
                str[179] = textBox168.Text;
                str[180] = textBox166.Text;
                str[181] = textBox164.Text;


                str[182] = textBox169.Text;//OP1流量上限
                str[183] = textBox170.Text;
                str[184] = textBox172.Text;
                str[185] = textBox167.Text;
                str[186] = textBox165.Text;
                str[187] = textBox163.Text;


                str[188] = textBox185.Text;//OP1出口压力下限
                str[189] = textBox186.Text;
                str[190] = textBox187.Text;
                str[191] = textBox184.Text;
                str[192] = textBox183.Text;
                str[193] = textBox182.Text;


                str[194] = textBox178.Text;//OP1出口压力上限
                str[195] = textBox179.Text;
                str[196] = textBox181.Text;
                str[197] = textBox177.Text;
                str[198] = textBox176.Text;
                str[199] = textBox175.Text;

                //LIN
                str[210] = textBox196.Text;//LIN-波特率
                str[211] = textBox117.Text;
                str[212] = textBox118.Text;
                str[213] = textBox258.Text;

                //起始位
                str[221] = textBox202.Text;
                str[222] = textBox201.Text;
                str[223] = textBox200.Text;
                str[224] = textBox199.Text;

                //精度
                str[231] = textBox212.Text;
                str[232] = textBox211.Text;
                str[233] = textBox210.Text;
                str[234] = textBox209.Text;

                //偏移
                str[239] = textBox233.Text;
                str[240] = textBox232.Text;
                str[241] = textBox231.Text;
                str[242] = textBox230.Text;

                str[245] = textBox119.Text;//过温-起始位
                str[246] = textBox120.Text;
                str[247] = textBox123.Text;
                str[248] = textBox130.Text;
                str[249] = textBox131.Text;
                str[250] = textBox124.Text;
                str[251] = textBox132.Text;

                str[260] = textBox224.Text;//目标速度-起始位              
                str[261] = textBox226.Text;
                str[262] = textBox229.Text;//目标速度-偏移

                str[270] = CheckBoxState2(checkBox20);
                str[271] = CheckBoxState2(checkBox13);
                str[272] = CheckBoxState2(checkBox12);
                str[273] = CheckBoxState2(checkBox11);
                str[274] = CheckBoxState2(checkBox52);
                str[275] = CheckBoxState2(checkBox53);
                str[276] = CheckBoxState2(checkBox54);

                //LIN

                str[280] = textBox205.Text;//额定转速


                str[281] = textBox206.Text;// 
                str[282] = textBox207.Text;// 
                str[283] = textBox208.Text;// 
                str[284] = textBox213.Text;// 
                str[285] = textBox214.Text;// 
                str[286] = textBox215.Text;// 

                str[300] = textBox133.Text;// 介质温度下限
                str[301] = textBox218.Text;// 
                str[302] = textBox221.Text;// 
                str[303] = textBox225.Text;// 
                str[304] = textBox234.Text;// 
                str[305] = textBox237.Text;// 
                str[306] = textBox278.Text;// 
                str[307] = textBox280.Text;// 
                str[308] = textBox279.Text;// 
                str[309] = textBox275.Text;// 
                str[310] = textBox261.Text;// 
                str[311] = textBox266.Text;// 
                str[312] = textBox270.Text;// 
                str[313] = textBox272.Text;// 
                str[314] = textBox271.Text;// 
                str[315] = textBox264.Text;// 
                str[316] = textBox256.Text;// 
                str[317] = textBox260.Text;// 
                str[318] = textBox257.Text;// 
                str[319] = textBox253.Text;// 


                str[340] = textBox99.Text;// 耐久时间
                str[341] = textBox100.Text;// 
                str[342] = textBox220.Text;// 
                str[343] = textBox223.Text;// 
                str[344] = textBox228.Text;// 
                str[345] = textBox236.Text;// 
                str[346] = textBox277.Text;// 
                str[347] = textBox276.Text;// 
                str[348] = textBox274.Text;// 
                str[349] = textBox273.Text;// 
                str[350] = textBox269.Text;// 
                str[351] = textBox268.Text;// 
                str[352] = textBox267.Text;// 
                str[353] = textBox265.Text;// 
                str[354] = textBox263.Text;// 
                str[355] = textBox262.Text;// 
                str[356] = textBox255.Text;// 
                str[357] = textBox254.Text;// 
                str[358] = textBox252.Text;//
                str[359] = textBox251.Text;// 


                str[360] = CheckBoxState2(checkBox25);
                str[361] = CheckBoxState2(checkBox28);
                str[362] = textBox60.Text;// 


                str[370] = CheckBoxState2(checkBox29);


                for (int i = 0; i < str.Length; i++)
                {
                    Str0 = Str0 + str[i] + "\r\n";
                }
                string Path0 = Path.Combine(StandardLB.RecipePath, str[0] + ".txt");

                StandardLB.TxtData(Path0, Str0, true);

                string[] filePaths = Directory.GetFiles(StandardLB.RecipePath);
                string[] Nmae = new string[filePaths.Length];
                for (int i = 0; i < filePaths.Length; i++)
                {
                    Nmae[i] = Path.GetFileNameWithoutExtension(filePaths[i]);
                }

                comboBox1.Items.Clear();
                for (int i = 0; i < Nmae.Length; i++)
                {
                    comboBox1.Items.Add(Nmae[i]);
                }
                comboBox1.SelectedIndex = 0;
            }



            else if (Idex == 2)   //更新参数
            {
                string[] str = new string[400];
                string Str0 = "";

                //  str[0] = textBox1.Text.Trim();

                str[10] = comboBox8.Text;
                str[11] = comboBox4.Text;
                str[12] = comboBox5.Text;
                str[13] = comboBox3.Text;
                str[14] = comboBox7.Text;
                str[15] = comboBox6.Text;

                str[30] = textBox114.Text.Trim();
                str[31] = textBox112.Text.Trim();
                str[32] = textBox111.Text.Trim();
                str[33] = textBox110.Text.Trim();
                str[34] = textBox109.Text.Trim();
                str[35] = textBox108.Text.Trim();

                str[50] = textBox107.Text.Trim();
                str[51] = textBox106.Text.Trim();
                str[52] = textBox105.Text.Trim();
                str[53] = textBox104.Text.Trim();
                str[54] = textBox103.Text.Trim();
                str[55] = textBox102.Text.Trim();

                str[64] = textBox216.Text.Trim();//下限
                str[65] = textBox217.Text.Trim();//上限

                str[71] = textBox19.Text.Trim();
                str[72] = textBox33.Text.Trim();
                str[73] = textBox50.Text.Trim();

                str[81] = textBox52.Text.Trim();
                str[82] = textBox55.Text.Trim();
                str[83] = textBox101.Text.Trim();

                str[91] = textBox56.Text.Trim();
                str[92] = textBox53.Text.Trim();
                str[93] = textBox51.Text.Trim();


                str[100] = textBox203.Text.Trim();//转速
                str[101] = textBox195.Text.Trim();
                str[102] = textBox194.Text.Trim();
                str[103] = textBox193.Text.Trim();
                str[104] = textBox192.Text.Trim();
                str[105] = textBox191.Text.Trim();

                str[139] = textBox49.Text;

                str[140] = textBox18.Text;//OP1电流下限
                str[141] = textBox15.Text;
                str[142] = textBox13.Text;
                str[143] = textBox25.Text;
                str[144] = textBox27.Text;
                str[145] = textBox137.Text;

                str[146] = textBox16.Text;//OP1电流上限
                str[147] = textBox2.Text;
                str[148] = textBox21.Text;
                str[149] = textBox20.Text;
                str[150] = textBox26.Text;
                str[151] = textBox136.Text;


                str[152] = textBox146.Text;//OP1电压下限
                str[153] = textBox148.Text;
                str[154] = textBox149.Text;
                str[155] = textBox143.Text;
                str[156] = textBox141.Text;
                str[157] = textBox139.Text;

                str[158] = textBox145.Text;//OP1电压上限
                str[159] = textBox147.Text;
                str[160] = textBox144.Text;
                str[161] = textBox142.Text;
                str[162] = textBox140.Text;
                str[163] = textBox138.Text;

                str[164] = textBox158.Text;//OP1功率下限
                str[165] = textBox161.Text;
                str[166] = textBox162.Text;
                str[167] = textBox155.Text;
                str[168] = textBox153.Text;
                str[169] = textBox151.Text;


                str[170] = textBox157.Text;//OP1功率上限
                str[171] = textBox160.Text;
                str[172] = textBox156.Text;
                str[173] = textBox154.Text;
                str[174] = textBox152.Text;
                str[175] = textBox150.Text;

                str[176] = textBox171.Text;//OP1流量下限
                str[177] = textBox173.Text;
                str[178] = textBox174.Text;
                str[179] = textBox168.Text;
                str[180] = textBox166.Text;
                str[181] = textBox164.Text;


                str[182] = textBox169.Text;//OP1流量上限
                str[183] = textBox170.Text;
                str[184] = textBox172.Text;
                str[185] = textBox167.Text;
                str[186] = textBox165.Text;
                str[187] = textBox163.Text;


                str[188] = textBox185.Text;//OP1出口压力下限
                str[189] = textBox186.Text;
                str[190] = textBox187.Text;
                str[191] = textBox184.Text;
                str[192] = textBox183.Text;
                str[193] = textBox182.Text;


                str[194] = textBox178.Text;//OP1出口压力上限
                str[195] = textBox179.Text;
                str[196] = textBox181.Text;
                str[197] = textBox177.Text;
                str[198] = textBox176.Text;
                str[199] = textBox175.Text;

                //LIN
                str[210] = textBox196.Text;//LIN-波特率
                str[211] = textBox117.Text;
                str[212] = textBox118.Text;
                str[213] = textBox258.Text;

                //起始位
                str[221] = textBox202.Text;
                str[222] = textBox201.Text;
                str[223] = textBox200.Text;
                str[224] = textBox199.Text;


                //精度
                str[231] = textBox212.Text;
                str[232] = textBox211.Text;
                str[233] = textBox210.Text;
                str[234] = textBox209.Text;


                //偏移
                str[239] = textBox233.Text;
                str[240] = textBox232.Text;
                str[241] = textBox231.Text;
                str[242] = textBox230.Text;


                str[245] = textBox119.Text;//过温-起始位
                str[246] = textBox120.Text;
                str[247] = textBox123.Text;
                str[248] = textBox130.Text;
                str[249] = textBox131.Text;
                str[250] = textBox124.Text;
                str[251] = textBox132.Text;

                str[260] = textBox224.Text;//目标速度-起始位              
                str[261] = textBox226.Text;
                str[262] = textBox229.Text;//目标速度-偏移

                str[270] = CheckBoxState2(checkBox20);
                str[271] = CheckBoxState2(checkBox13);
                str[272] = CheckBoxState2(checkBox12);
                str[273] = CheckBoxState2(checkBox11);
                str[274] = CheckBoxState2(checkBox52);
                str[275] = CheckBoxState2(checkBox53);
                str[276] = CheckBoxState2(checkBox54);

                //LIN
                str[280] = textBox205.Text;//额定转速

                str[281] = textBox206.Text;// 
                str[282] = textBox207.Text;// 
                str[283] = textBox208.Text;// 
                str[284] = textBox213.Text;// 
                str[285] = textBox214.Text;// 
                str[286] = textBox215.Text;// 

                str[300] = textBox133.Text;// 介质温度下限
                str[301] = textBox218.Text;// 
                str[302] = textBox221.Text;// 
                str[303] = textBox225.Text;// 
                str[304] = textBox234.Text;// 
                str[305] = textBox237.Text;// 
                str[306] = textBox278.Text;// 
                str[307] = textBox280.Text;// 
                str[308] = textBox279.Text;// 
                str[309] = textBox275.Text;// 
                str[310] = textBox261.Text;// 
                str[311] = textBox266.Text;// 
                str[312] = textBox270.Text;// 
                str[313] = textBox272.Text;// 
                str[314] = textBox271.Text;// 
                str[315] = textBox264.Text;// 
                str[316] = textBox256.Text;// 
                str[317] = textBox260.Text;// 
                str[318] = textBox257.Text;// 
                str[319] = textBox253.Text;// 

                str[340] = textBox99.Text;// 耐久时间
                str[341] = textBox100.Text;// 
                str[342] = textBox220.Text;// 
                str[343] = textBox223.Text;// 
                str[344] = textBox228.Text;// 
                str[345] = textBox236.Text;// 
                str[346] = textBox277.Text;// 
                str[347] = textBox276.Text;// 
                str[348] = textBox274.Text;// 
                str[349] = textBox273.Text;// 
                str[350] = textBox269.Text;// 
                str[351] = textBox268.Text;// 
                str[352] = textBox267.Text;// 
                str[353] = textBox265.Text;// 
                str[354] = textBox263.Text;// 
                str[355] = textBox262.Text;// 
                str[356] = textBox255.Text;// 
                str[357] = textBox254.Text;// 
                str[358] = textBox252.Text;//
                str[359] = textBox251.Text;//

                str[360] = CheckBoxState2(checkBox25);
                str[361] = CheckBoxState2(checkBox28);

                str[362] = textBox60.Text;// 


                str[370] = CheckBoxState2(checkBox29);


                for (int i = 0; i < str.Length; i++)
                {
                    Str0 = Str0 + str[i] + "\r\n";
                }
                string Path0 = Path.Combine(StandardLB.RecipePath, comboBox1.Text.Trim() + ".txt");

                StandardLB.TxtData(Path0, Str0, false);
            }



            else if (Idex == 3)   //读取参数
            {

                string Path0 = Path.Combine(StandardLB.RecipePath, comboBox1.Text.Trim() + ".txt");
                StandardLB.RecipeParameter = File.ReadAllLines(Path0);

                comboBox8.Text = StandardLB.RecipeParameter[10];
                comboBox4.Text = StandardLB.RecipeParameter[11];
                comboBox5.Text = StandardLB.RecipeParameter[12];
                comboBox3.Text = StandardLB.RecipeParameter[13];
                comboBox7.Text = StandardLB.RecipeParameter[14];
                comboBox6.Text = StandardLB.RecipeParameter[15];

                textBox114.Text = StandardLB.RecipeParameter[30];
                textBox112.Text = StandardLB.RecipeParameter[31];
                textBox111.Text = StandardLB.RecipeParameter[32];
                textBox110.Text = StandardLB.RecipeParameter[33];
                textBox109.Text = StandardLB.RecipeParameter[34];
                textBox108.Text = StandardLB.RecipeParameter[35];

                textBox107.Text = StandardLB.RecipeParameter[50];
                textBox106.Text = StandardLB.RecipeParameter[51];
                textBox105.Text = StandardLB.RecipeParameter[52];
                textBox104.Text = StandardLB.RecipeParameter[53];
                textBox103.Text = StandardLB.RecipeParameter[54];
                textBox102.Text = StandardLB.RecipeParameter[55];

                textBox216.Text = StandardLB.RecipeParameter[64];
                textBox217.Text = StandardLB.RecipeParameter[65];

                textBox19.Text = StandardLB.RecipeParameter[71];
                textBox33.Text = StandardLB.RecipeParameter[72];
                textBox50.Text = StandardLB.RecipeParameter[73];

                textBox52.Text = StandardLB.RecipeParameter[81];
                textBox55.Text = StandardLB.RecipeParameter[82];
                textBox101.Text = StandardLB.RecipeParameter[83];

                textBox56.Text = StandardLB.RecipeParameter[91];
                textBox53.Text = StandardLB.RecipeParameter[92];
                textBox51.Text = StandardLB.RecipeParameter[93];

                textBox203.Text = StandardLB.RecipeParameter[100];
                textBox195.Text = StandardLB.RecipeParameter[101];
                textBox194.Text = StandardLB.RecipeParameter[102];
                textBox193.Text = StandardLB.RecipeParameter[103];
                textBox192.Text = StandardLB.RecipeParameter[104];
                textBox191.Text = StandardLB.RecipeParameter[105];

                textBox49.Text = StandardLB.RecipeParameter[139];

                textBox18.Text = StandardLB.RecipeParameter[140];//OP1电流下限
                textBox15.Text = StandardLB.RecipeParameter[141];
                textBox13.Text = StandardLB.RecipeParameter[142];
                textBox25.Text = StandardLB.RecipeParameter[143];
                textBox27.Text = StandardLB.RecipeParameter[144];
                textBox137.Text = StandardLB.RecipeParameter[145];

                textBox16.Text = StandardLB.RecipeParameter[146];//OP1电流上限
                textBox2.Text = StandardLB.RecipeParameter[147];
                textBox21.Text = StandardLB.RecipeParameter[148];
                textBox20.Text = StandardLB.RecipeParameter[149];
                textBox26.Text = StandardLB.RecipeParameter[150];
                textBox136.Text = StandardLB.RecipeParameter[151];


                textBox146.Text = StandardLB.RecipeParameter[152];//OP1电压下限
                textBox148.Text = StandardLB.RecipeParameter[153];
                textBox149.Text = StandardLB.RecipeParameter[154];
                textBox143.Text = StandardLB.RecipeParameter[155];
                textBox141.Text = StandardLB.RecipeParameter[156];
                textBox139.Text = StandardLB.RecipeParameter[157];

                textBox145.Text = StandardLB.RecipeParameter[158];//OP1电压上限
                textBox147.Text = StandardLB.RecipeParameter[159];
                textBox144.Text = StandardLB.RecipeParameter[160];
                textBox142.Text = StandardLB.RecipeParameter[161];
                textBox140.Text = StandardLB.RecipeParameter[162];
                textBox138.Text = StandardLB.RecipeParameter[163];

                textBox158.Text = StandardLB.RecipeParameter[164];//OP1功率下限
                textBox161.Text = StandardLB.RecipeParameter[165];
                textBox162.Text = StandardLB.RecipeParameter[166];
                textBox155.Text = StandardLB.RecipeParameter[167];
                textBox153.Text = StandardLB.RecipeParameter[168];
                textBox151.Text = StandardLB.RecipeParameter[169];


                textBox157.Text = StandardLB.RecipeParameter[170];//OP1功率上限
                textBox160.Text = StandardLB.RecipeParameter[171];
                textBox156.Text = StandardLB.RecipeParameter[172];
                textBox154.Text = StandardLB.RecipeParameter[173];
                textBox152.Text = StandardLB.RecipeParameter[174];
                textBox150.Text = StandardLB.RecipeParameter[175];

                textBox171.Text = StandardLB.RecipeParameter[176];//OP1流量下限
                textBox173.Text = StandardLB.RecipeParameter[177];
                textBox174.Text = StandardLB.RecipeParameter[178];
                textBox168.Text = StandardLB.RecipeParameter[179];
                textBox166.Text = StandardLB.RecipeParameter[180];
                textBox164.Text = StandardLB.RecipeParameter[181];


                textBox169.Text = StandardLB.RecipeParameter[182];//OP1流量上限
                textBox170.Text = StandardLB.RecipeParameter[183];
                textBox172.Text = StandardLB.RecipeParameter[184];
                textBox167.Text = StandardLB.RecipeParameter[185];
                textBox165.Text = StandardLB.RecipeParameter[186];
                textBox163.Text = StandardLB.RecipeParameter[187];


                textBox185.Text = StandardLB.RecipeParameter[188];//OP1出口压力下限
                textBox186.Text = StandardLB.RecipeParameter[189];
                textBox187.Text = StandardLB.RecipeParameter[190];
                textBox184.Text = StandardLB.RecipeParameter[191];
                textBox183.Text = StandardLB.RecipeParameter[192];
                textBox182.Text = StandardLB.RecipeParameter[193];


                textBox178.Text = StandardLB.RecipeParameter[194];//OP1出口压力上限
                textBox179.Text = StandardLB.RecipeParameter[195];
                textBox181.Text = StandardLB.RecipeParameter[196];
                textBox177.Text = StandardLB.RecipeParameter[197];
                textBox176.Text = StandardLB.RecipeParameter[198];
                textBox175.Text = StandardLB.RecipeParameter[199];

                //LIN
                textBox196.Text = StandardLB.RecipeParameter[210];//LIN-波特率
                textBox117.Text = StandardLB.RecipeParameter[211];
                textBox118.Text = StandardLB.RecipeParameter[212];
                textBox258.Text = StandardLB.RecipeParameter[213];

                ;//起始位
                textBox202.Text = StandardLB.RecipeParameter[221];
                textBox201.Text = StandardLB.RecipeParameter[222];
                textBox200.Text = StandardLB.RecipeParameter[223];
                textBox199.Text = StandardLB.RecipeParameter[224];


                //精度
                textBox212.Text = StandardLB.RecipeParameter[231];
                textBox211.Text = StandardLB.RecipeParameter[232];
                textBox210.Text = StandardLB.RecipeParameter[233];
                textBox209.Text = StandardLB.RecipeParameter[234];

                //偏移
                textBox233.Text = StandardLB.RecipeParameter[239];
                textBox232.Text = StandardLB.RecipeParameter[240];
                textBox231.Text = StandardLB.RecipeParameter[241];
                textBox230.Text = StandardLB.RecipeParameter[242];


                textBox119.Text = StandardLB.RecipeParameter[245];//过温-起始位
                textBox120.Text = StandardLB.RecipeParameter[246];
                textBox123.Text = StandardLB.RecipeParameter[247];
                textBox130.Text = StandardLB.RecipeParameter[248];
                textBox131.Text = StandardLB.RecipeParameter[249];
                textBox124.Text = StandardLB.RecipeParameter[250];
                textBox132.Text = StandardLB.RecipeParameter[251];

                textBox224.Text = StandardLB.RecipeParameter[260];//目标速度-起始位              
                textBox226.Text = StandardLB.RecipeParameter[261];
                textBox229.Text = StandardLB.RecipeParameter[262];//目标速度-偏移

                CheckBoxState1(checkBox20, StandardLB.RecipeParameter[270]);
                CheckBoxState1(checkBox13, StandardLB.RecipeParameter[271]);
                CheckBoxState1(checkBox12, StandardLB.RecipeParameter[272]);
                CheckBoxState1(checkBox11, StandardLB.RecipeParameter[273]);
                CheckBoxState1(checkBox52, StandardLB.RecipeParameter[274]);
                CheckBoxState1(checkBox53, StandardLB.RecipeParameter[275]);
                CheckBoxState1(checkBox54, StandardLB.RecipeParameter[276]);

                //LIN
                textBox205.Text = StandardLB.RecipeParameter[280];//额定转速
                textBox206.Text = StandardLB.RecipeParameter[281];


                textBox206.Text = StandardLB.RecipeParameter[281];
                textBox207.Text = StandardLB.RecipeParameter[282];
                textBox208.Text = StandardLB.RecipeParameter[283];
                textBox213.Text = StandardLB.RecipeParameter[284];
                textBox214.Text = StandardLB.RecipeParameter[285];
                textBox215.Text = StandardLB.RecipeParameter[286];

                textBox133.Text = StandardLB.RecipeParameter[300];// 设定温度
                textBox218.Text = StandardLB.RecipeParameter[301];// 
                textBox221.Text = StandardLB.RecipeParameter[302];// 
                textBox225.Text = StandardLB.RecipeParameter[303];// 
                textBox234.Text = StandardLB.RecipeParameter[304];// 
                textBox237.Text = StandardLB.RecipeParameter[305];// 
                textBox278.Text = StandardLB.RecipeParameter[306];// 
                textBox280.Text = StandardLB.RecipeParameter[307];// 
                textBox279.Text = StandardLB.RecipeParameter[308];// 
                textBox275.Text = StandardLB.RecipeParameter[309];// 
                textBox261.Text = StandardLB.RecipeParameter[310];// 
                textBox266.Text = StandardLB.RecipeParameter[311];// 
                textBox270.Text = StandardLB.RecipeParameter[312];// 
                textBox272.Text = StandardLB.RecipeParameter[313];// 
                textBox271.Text = StandardLB.RecipeParameter[314];// 
                textBox264.Text = StandardLB.RecipeParameter[315];// 
                textBox256.Text = StandardLB.RecipeParameter[316];// 
                textBox260.Text = StandardLB.RecipeParameter[317];// 
                textBox257.Text = StandardLB.RecipeParameter[318];// +
                textBox253.Text = StandardLB.RecipeParameter[319];// 

                textBox99.Text = StandardLB.RecipeParameter[340];// 耐久时间
                textBox100.Text = StandardLB.RecipeParameter[341];// 
                textBox220.Text = StandardLB.RecipeParameter[342];// 
                textBox223.Text = StandardLB.RecipeParameter[343];// 
                textBox228.Text = StandardLB.RecipeParameter[344];// 
                textBox236.Text = StandardLB.RecipeParameter[345];// 
                textBox277.Text = StandardLB.RecipeParameter[346];// 
                textBox276.Text = StandardLB.RecipeParameter[347];// 
                textBox274.Text = StandardLB.RecipeParameter[348];// 
                textBox273.Text = StandardLB.RecipeParameter[349];// 
                textBox269.Text = StandardLB.RecipeParameter[350];// 
                textBox268.Text = StandardLB.RecipeParameter[351];// 
                textBox267.Text = StandardLB.RecipeParameter[352];// 
                textBox265.Text = StandardLB.RecipeParameter[353];// 
                textBox263.Text = StandardLB.RecipeParameter[354];// 
                textBox262.Text = StandardLB.RecipeParameter[355];// 
                textBox255.Text = StandardLB.RecipeParameter[356];// 
                textBox254.Text = StandardLB.RecipeParameter[357];// 
                textBox252.Text = StandardLB.RecipeParameter[358];// 
                textBox251.Text = StandardLB.RecipeParameter[359];// 


                CheckBoxState1(checkBox25, StandardLB.RecipeParameter[360]);
                CheckBoxState1(checkBox28, StandardLB.RecipeParameter[361]);

                textBox60.Text = StandardLB.RecipeParameter[362];// 


                CheckBoxState1(checkBox29, StandardLB.RecipeParameter[370]);

                // 修改原有的6段计算为20段计算
                try
                {
                    float totalTime = 0;
                    for (int i = 0; i < 20; i++)
                    {
                        float segmentTime = float.Parse(StandardLB.RecipeParameter[340 + i]) * 3600;
                        totalTime += segmentTime;
                        StandardLB.Temperature_Time[i] = totalTime;
                    }
                }
                catch (Exception ex)
                {
                    // 处理异常
                    MessageBox.Show($"温度时间参数设置错误: {ex.Message}");
                }

                StandardLB.cycle0 = StandardLB.Parameterfloat[71] + StandardLB.Parameterfloat[72];//启停1周期
                StandardLB.cycle1 = StandardLB.Parameterfloat[81] + StandardLB.Parameterfloat[82];//启停2周期
                StandardLB.cycle2 = StandardLB.Parameterfloat[91] + StandardLB.Parameterfloat[92];//启停3周期



                groupBox2.Text = "OP1-" + StandardLB.RecipeParameter[30] + "-" + StandardLB.RecipeParameter[50];
                groupBox3.Text = "OP2-" + StandardLB.RecipeParameter[31] + "-" + StandardLB.RecipeParameter[51];
                groupBox5.Text = "OP3-" + StandardLB.RecipeParameter[32] + "-" + StandardLB.RecipeParameter[52];
                groupBox6.Text = "OP4-" + StandardLB.RecipeParameter[33] + "-" + StandardLB.RecipeParameter[53];
                groupBox7.Text = "OP5" + StandardLB.RecipeParameter[34] + "-" + StandardLB.RecipeParameter[54];
                groupBox8.Text = "OP6-" + StandardLB.RecipeParameter[35] + "-" + StandardLB.RecipeParameter[55];

                textBox6.Text = StandardLB.RecipeParameter[10];
                textBox28.Text = StandardLB.RecipeParameter[11];
                textBox57.Text = StandardLB.RecipeParameter[12];
                textBox67.Text = StandardLB.RecipeParameter[13];
                textBox75.Text = StandardLB.RecipeParameter[14];
                textBox86.Text = StandardLB.RecipeParameter[15];


                StandardLB.TsetMode[0] = comboBox8.SelectedIndex;
                StandardLB.TsetMode[1] = comboBox4.SelectedIndex;
                StandardLB.TsetMode[2] = comboBox5.SelectedIndex;
                StandardLB.TsetMode[3] = comboBox3.SelectedIndex;
                StandardLB.TsetMode[4] = comboBox7.SelectedIndex;
                StandardLB.TsetMode[5] = comboBox6.SelectedIndex;



                if (uiSwitch29.Active)
                {
                    if (StandardLB.RecipeParameter[10] == "耐久测试")
                    {
                        textBox6.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[10] == "启停模式1")
                    {
                        textBox6.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[10] == "启停模式2")
                    {
                        textBox6.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[10] == "启停模式3")
                    {
                        textBox6.Text = "Start Stop Test 3";
                    }

                    if (StandardLB.RecipeParameter[11] == "耐久测试")
                    {
                        textBox28.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[11] == "启停模式1")
                    {
                        textBox28.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[11] == "启停模式2")
                    {
                        textBox28.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[11] == "启停模式3")
                    {
                        textBox28.Text = "Start Stop Test 3";
                    }

                    if (StandardLB.RecipeParameter[12] == "耐久测试")
                    {
                        textBox57.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[12] == "启停模式1")
                    {
                        textBox57.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[12] == "启停模式2")
                    {
                        textBox57.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[12] == "启停模式3")
                    {
                        textBox57.Text = "Start Stop Test 3";
                    }

                    if (StandardLB.RecipeParameter[13] == "耐久测试")
                    {
                        textBox67.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[13] == "启停模式1")
                    {
                        textBox67.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[13] == "启停模式2")
                    {
                        textBox67.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[13] == "启停模式3")
                    {
                        textBox67.Text = "Start Stop Test 3";
                    }



                    if (StandardLB.RecipeParameter[14] == "耐久测试")
                    {
                        textBox75.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[14] == "启停模式1")
                    {
                        textBox75.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[14] == "启停模式2")
                    {
                        textBox75.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[14] == "启停模式3")
                    {
                        textBox75.Text = "Start Stop Test 3";
                    }


                    if (StandardLB.RecipeParameter[15] == "耐久测试")
                    {
                        textBox86.Text = "Durability Test";
                    }
                    else if (StandardLB.RecipeParameter[15] == "启停模式1")
                    {
                        textBox86.Text = "Start Stop Test 1";
                    }
                    else if (StandardLB.RecipeParameter[15] == "启停模式2")
                    {
                        textBox86.Text = "Start Stop Test 2";
                    }
                    else if (StandardLB.RecipeParameter[15] == "启停模式3")
                    {
                        textBox86.Text = "Start Stop Test 3";
                    }
                }


                try
                {
                    byte a = Convert.ToByte(StandardLB.RecipeParameter[211], 16);
                    byte b = Convert.ToByte(StandardLB.RecipeParameter[212], 16);
                    StandardLB.ID0[0] = a;
                    StandardLB.ID0[1] = b;

                }
                catch (Exception ex) { }







                for (int i = 1; i < StandardLB.RecipeParameter.Length; i++)
                {
                    if (float.TryParse(StandardLB.RecipeParameter[i], out float val1))
                    {
                        StandardLB.Parameterfloat[i] = val1;
                    }
                }

                for (int i = 0; i < 6; i++)
                {
                    StandardLB.CurrentDown[i] = StandardLB.Parameterfloat[140 + i];
                    StandardLB.CurrentUP[i] = StandardLB.Parameterfloat[146 + i];
                    StandardLB.VoltageDown[i] = StandardLB.Parameterfloat[152 + i];
                    StandardLB.VoltageUP[i] = StandardLB.Parameterfloat[158 + i];

                    StandardLB.InPowerDown[i] = StandardLB.Parameterfloat[164 + i];
                    StandardLB.InPowerUp[i] = StandardLB.Parameterfloat[170 + i];
                    StandardLB.FlowDown[i] = StandardLB.Parameterfloat[176 + i];
                    StandardLB.FlowUP[i] = StandardLB.Parameterfloat[182 + i];

                    StandardLB.OutpressureDown[i] = StandardLB.Parameterfloat[188 + i];
                    StandardLB.OutpressureUp[i] = StandardLB.Parameterfloat[194 + i];

                    StandardLB.InputpressureDown[i] = StandardLB.Parameterfloat[64];
                    StandardLB.InputpressureUp[i] = StandardLB.Parameterfloat[65];

                }





            }
            else if (Idex == 4)//读取产品
            {
                string[] filePaths = Directory.GetFiles(StandardLB.RecipePath);
                string[] Nmae = new string[filePaths.Length];
                for (int i = 0; i < filePaths.Length; i++)
                {
                    Nmae[i] = Path.GetFileNameWithoutExtension(filePaths[i]);
                }
                for (int i = 0; i < Nmae.Length; i++)
                {
                    comboBox1.Items.Add(Nmae[i]);
                }
                comboBox1.Text = Login_NoSQL.CBIndex;
            }
            else if (Idex == 5)//删除数据
            {
                string[] filePaths0 = Directory.GetFiles(StandardLB.RecipePath);
                string[] Nmae0 = new string[filePaths0.Length];
                if (Nmae0.Length > 1)
                {
                    string Path0 = Path.Combine(StandardLB.RecipePath, comboBox1.Text.Trim() + ".txt");
                    File.Delete(Path0);

                    comboBox1.Items.Clear();

                    string[] filePaths1 = Directory.GetFiles(StandardLB.RecipePath);
                    string[] Nmae1 = new string[filePaths1.Length];
                    for (int i = 0; i < filePaths1.Length; i++)
                    {
                        Nmae1[i] = Path.GetFileNameWithoutExtension(filePaths1[i]);
                    }
                    for (int i = 0; i < Nmae1.Length; i++)
                    {
                        comboBox1.Items.Add(Nmae1[i]);
                    }
                    comboBox1.Text = Nmae1[0];

                }
                else
                {

                    MessageBox.Show("配方数量过小，请重新添加", "提示信息", MessageBoxButtons.YesNo);
                }


            }


        }


        // 手动写入PLC布尔量方法 - 将界面开关状态同步到PLC
        public void Man_WiterPLCBool()
        {
            // 调用ManControl方法处理各个开关与PLC地址的映射关系
            // uiSwitch2 对应 PLC地址1
            ManControl(uiSwitch2, 1);

            // 处理6个工位的启动开关，分别对应PLC地址5-10
            ManControl(uiSwitch3, 5);   // 工位1启动开关 -> PLC地址5
            ManControl(uiSwitch6, 6);   // 工位2启动开关 -> PLC地址6
            ManControl(uiSwitch9, 7);   // 工位3启动开关 -> PLC地址7
            ManControl(uiSwitch18, 8);  // 工位4启动开关 -> PLC地址8
            ManControl(uiSwitch15, 9);  // 工位5启动开关 -> PLC地址9
            ManControl(uiSwitch12, 10); // 工位6启动开关 -> PLC地址10

            // 处理其他功能开关
            ManControl(uiSwitch20, 23); // 功能开关 -> PLC地址23
            ManControl(uiSwitch28, 24); // 功能开关 -> PLC地址24
            ManControl(uiSwitch23, 25); // 功能开关 -> PLC地址25
            ManControl(uiSwitch21, 26); // 功能开关 -> PLC地址26
            ManControl(uiSwitch24, 27); // 功能开关 -> PLC地址27
            ManControl(uiSwitch11, 31); // 功能开关 -> PLC地址31

            ManControl(uiSwitch13, 34); // 功能开关 -> PLC地址34
        }

        // 手动控制方法 - 根据UI开关状态写入对应的PLC布尔量
        public void ManControl(UISwitch UI, int Idex)
        {
            // 检查UI开关是否处于激活状态
            if (UI.Active)
            {
                // 如果开关激活，向PLC对应地址写入true
                StandardLB.WiterPLCBool(Idex, true);
            }
            else
            {
                // 如果开关未激活，向PLC对应地址写入false
                StandardLB.WiterPLCBool(Idex, false);
            }
        }

        // 数据缓冲区初始化方法 - 为LIN通信准备数据缓冲区
        private void DataBuffers()
        {
            // 遍历20个数据缓冲区（实际使用6个，预留扩展）
            for (int i = 0; i < 20; i++)
            {
                // 为每个LIN数据缓冲区分配8字节空间，初始化为全0
                BaseClass1.DataBuffersArrayLIN[i] = new byte[8] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            }
        }

        // 字符串数组管理器初始化方法 - 为LIN响应数据准备字符串数组
        private void StringArraysManager()
        {
            // 遍历20个字符串数组（实际使用6个，预留扩展）
            for (int i = 0; i < 20; i++)
            {
                // 为每个LIN响应数组分配10个字符串元素，初始化为空字符串
                BaseClass1.LINRArrays[i] = new string[10] { "", "", "", "", "", "", "", "", "", "" };
            }
        }

        // 主控件初始化方法 - 将界面控件分配到对应的数组中进行统一管理
        private void MainControl()
        {
            // 初始化6个工位的条码显示标签数组
            StandardLB.labelContol = new Label[6] { label210, label204, label206, label209, label230, label240 };

            // 初始化6个工位的条码使能复选框数组
            StandardLB.CBox = new CheckBox[6] { checkBox19, checkBox18, checkBox17, checkBox14, checkBox15, checkBox16 };

            // 初始化6个工位的状态显示文本框数组
            TB_DS = new TextBox[6] { textBox17, textBox125, textBox126, textBox127, textBox128, textBox129 };

            // 初始化6个工位的图表控件数组
            CT = new Chart[6] { chart6, chart1, chart2, chart3, chart4, chart5 };

            // 初始化6个工位的图表显示控制复选框数组
            CBox_CT = new CheckBox[6] { checkBox1, checkBox2, checkBox3, checkBox4, checkBox9, checkBox10 };

            // 初始化6个工位的LIN通信使能复选框数组
            CBox_LIN = new CheckBox[6] { checkBox21, checkBox22, checkBox23, checkBox24, checkBox26, checkBox27 };

            // 初始化6个工位的电流显示文本框数组
            TB_C = new TextBox[6] { textBox159, textBox47, textBox64, textBox72, textBox82, textBox91 };

            // 初始化6个工位的电压显示文本框数组
            TB_A = new TextBox[6] { textBox84, textBox46, textBox63, textBox71, textBox80, textBox90 };

            // 初始化6个工位的功率显示文本框数组
            TB_Power = new TextBox[6] { textBox81, textBox45, textBox62, textBox70, textBox78, textBox89 };

            // 初始化6个工位的输入压力显示文本框数组
            TB_INP = new TextBox[6] { textBox79, textBox44, textBox61, textBox69, textBox77, textBox88 };

            // 初始化6个工位的输出压力显示文本框数组
            TB_OUTP = new TextBox[6] { textBox3, textBox14, textBox54, textBox66, textBox74, textBox85 };

            // 初始化6个工位的压差显示文本框数组
            TB_DiffP = new TextBox[6] { textBox9, textBox12, textBox48, textBox65, textBox73, textBox83 };

            // 初始化6个工位的流量显示文本框数组
            TB_Flow = new TextBox[6] { textBox59, textBox92, textBox93, textBox94, textBox95, textBox97 };

            // 初始化6个工位的状态指示灯图片框数组
            PB_State = new PictureBox[6] { pictureBox67, pictureBox59, pictureBox60, pictureBox61, pictureBox62, pictureBox63 };

            // 初始化6个工位的启动开关数组
            UIStart = new UISwitch[6] { uiSwitch1, uiSwitch4, uiSwitch5, uiSwitch7, uiSwitch8, uiSwitch10 };
        }

        // 获取图片方法 - 根据状态设置图片框显示的图片（旧版本，保留兼容性）
        public void GetPictures(PictureBox P1, int S1)
        {
            // 使用BeginInvoke确保在UI线程上执行图片更新
            this.BeginInvoke((EventHandler)delegate
            {
                // 根据状态参数S1选择不同的图片显示方案
                switch (S1)
                {
                    case 0:  // 状态0：显示绿色图片和相关控件
                        label120.Visible = true;      // 显示标签
                        pictureBox59.Visible = true;  // 显示图片框
                                                      // 加载绿色状态图片资源
                        images1[0] = WindowsFormsApp15.Properties.Resources.G;
                        P1.Image = images1[0];        // 设置图片框图像
                        break;
                    case 1:  // 状态1：显示红色图片和相关控件
                        label120.Visible = true;      // 显示标签
                        pictureBox59.Visible = true;  // 显示图片框
                                                      // 加载红色状态图片资源
                        images1[1] = WindowsFormsApp15.Properties.Resources.R;
                        P1.Image = images1[1];        // 设置图片框图像
                        break;
                    case 2:  // 状态2：隐藏相关控件
                        label120.Visible = false;     // 隐藏标签
                        pictureBox59.Visible = false; // 隐藏图片框
                        break;
                }
            });
        }

        // 获取图片方法1 - 根据状态设置图片框显示的图片（新版本，功能更丰富）
        public void GetPictures1(PictureBox P1, int S1)
        {
            // 使用BeginInvoke确保在UI线程上执行图片更新
            this.BeginInvoke((EventHandler)delegate
            {
                // 根据状态参数S1选择不同的图片显示方案
                switch (S1)
                {
                    case 0:  // 状态0：显示红色图片（报警/停止状态）
                        images1[0] = WindowsFormsApp15.Properties.Resources.R;
                        P1.Image = images1[0];  // 设置红色状态图片
                        break;
                    case 1:  // 状态1：显示绿色图片（正常运行状态）
                        images1[1] = WindowsFormsApp15.Properties.Resources.G;
                        P1.Image = images1[1];  // 设置绿色状态图片
                        break;
                    case 2:  // 状态2：显示灰色图片（待机/未运行状态）
                        images1[1] = WindowsFormsApp15.Properties.Resources.R1;
                        P1.Image = images1[1];  // 设置灰色状态图片
                        break;
                    case 3:  // 状态3：显示黄色图片（准备/等待状态）
                        images1[1] = WindowsFormsApp15.Properties.Resources.Y;
                        P1.Image = images1[1];  // 设置黄色状态图片
                        break;
                }
            });
        }

        // IO状态图片显示方法 - 根据布尔状态设置图片框显示绿色或灰色
        private void GetPictures_IO(PictureBox P1, bool B1)
        {
            // 检查布尔状态值
            if (B1)
            {
                // 如果状态为true，显示绿色图片（激活状态）
                images1[1] = WindowsFormsApp15.Properties.Resources.G;
                P1.Image = images1[1];
            }
            else
            {
                // 如果状态为false，显示灰色图片（非激活状态）
                images1[0] = WindowsFormsApp15.Properties.Resources.R1;
                P1.Image = images1[0];
            }
        }

        // 复选框状态设置方法1 - 根据字符串值设置复选框的选中状态
        private void CheckBoxState1(CheckBox C1, string Str)
        {
            // 检查字符串值是否为"0"
            if (Str == "0")
            {
                // 如果字符串为"0"，取消选中复选框
                C1.Checked = false;
            }
            else
            {
                // 如果字符串不为"0"，选中复选框
                C1.Checked = true;
            }
        }

        // 复选框状态获取方法2 - 获取复选框的选中状态并转换为字符串
        private string CheckBoxState2(CheckBox C1)
        {
            // 检查复选框是否被选中
            if (C1.Checked)
            {
                // 如果选中，返回"1"
                return "1";
            }
            else
            {
                // 如果未选中，返回"0"
                return "0";
            }
        }

        // 单选按钮状态设置方法1 - 根据字符串值设置单选按钮的选中状态
        private void RadioButtonState1(RadioButton C1, string Str)
        {
            // 检查字符串值是否为"0"
            if (Str == "0")
            {
                // 如果字符串为"0"，取消选中单选按钮
                C1.Checked = false;
            }
            else
            {
                // 如果字符串不为"0"，选中单选按钮
                C1.Checked = true;
            }
        }

        // 单选按钮状态获取方法2 - 获取单选按钮的选中状态并转换为字符串
        private string RadioButtonState2(RadioButton C1)
        {
            if (C1.Checked)
            {
                return "1";
            }
            else
            {
                return "0";
            }


        }


        // UI开关状态处理方法 - 根据工位和操作类型控制开关状态和PLC通信
        private void UISwitchHandle(int Station, int Idex)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                switch (Idex)
                {
                    // 强制关闭工位
                    case 0:
                        // 向PLC写入false，停止该工位
                        StandardLB.WiterPLCBool(Station + 11, false);// 写入PLC停止信号
                        UIStart[Station].Active = false;// 更新UI开关状态
                        break;
                    case 1: // 根据开关状态控制工位
                        // 如果UI开关激活，向PLC写入true启动工位
                        if (UIStart[Station].Active)
                        {
                            StandardLB.WiterPLCBool(Station + 11, true);// 启动
                        }
                        else
                        {
                            // 如果UI开关未激活，向PLC写入false停止工位
                            StandardLB.WiterPLCBool(Station + 11, false);// 停止
                        }
                        break;

                    case 2: // 自动停止处理
                        // 如果UI开关未激活且工位正在运行
                        if (!UIStart[Station].Active)
                        {
                            StandardLB.WiterPLCBool(Station + 11, false);  // 停止PLC
                            GetPictures1(PB_State[Station], 2);            // 显示灰色指示灯
                            StandardLB.WiterPLCcomplete(Station, 15);      // 写入完成状态
                        }

                        break;
                }
            });
        }


        // 地图状态更新方法 - 根据PLC状态更新进度条显示
        private void Map()
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 主液罐状态处理 - 根据状态4和状态5的组合设置进度值
                if (StandardLB.State[4] && StandardLB.State[5])
                {
                    // 两个状态都为true，设置进度为5%（低液位）
                    ucProcessWave1.Value = 5; // 两个状态都为true，值=5
                }
                else if (StandardLB.State[4] && !StandardLB.State[5])
                {
                    // 状态4为true，状态5为false，设置进度为70%（中等液位）
                    ucProcessWave1.Value = 70;// 只有状态4为true，值=70
                }
                else if (!StandardLB.State[4] && !StandardLB.State[5])
                {
                    // 两个状态都为false，设置进度为100%（高液位）
                    ucProcessWave1.Value = 100; // 两个状态都为false，值=100
                }


                // 辅液罐状态处理 - 根据状态22和状态6的组合设置进度值
                if (StandardLB.State[22] && StandardLB.State[6])
                {
                    // 两个状态都为true，设置进度为5%（低液位）
                    ucProcessWave2.Value = 5; // 两个状态都为true，值=5
                }
                else if (StandardLB.State[22] && !StandardLB.State[6])
                {
                    // 状态22为true，状态6为false，设置进度为70%（中等液位）
                    ucProcessWave2.Value = 70;// 只有状态22为true，值=70
                }
                else if (!StandardLB.State[22] && !StandardLB.State[6])
                {
                    // 两个状态都为false，设置进度为100%（高液位）
                    ucProcessWave2.Value = 100;// 两个状态都为false，值=100
                }
            });
        }


        // Label更新方法 - 根据索引值设置Label的显示属性和文本
        public void UpdateLabel(Label L1, string str, int Idex)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                switch (Idex)
                {
                    case 1:  // 状态1：绿色背景，正常状态
                        L1.BackColor = Color.Lime;  // 设置背景色为绿色
                        L1.Text = str;              // 设置显示文本
                        break;
                    case 2:  // 状态2：红色背景，报警状态
                        L1.BackColor = Color.Red;   // 设置背景色为红色
                        L1.Text = str;              // 设置显示文本
                        break;
                    case 3:  // 状态3：绿色背景，完成状态
                        L1.BackColor = Color.Green; // 设置背景色为绿色
                        L1.Text = str;              // 设置显示文本
                        break;
                    case 4:  // 状态4：仅更新文本，不改变背景色
                        L1.Text = str;              // 设置显示文本
                        break;
                    case 5:  // 状态5：灰色背景，禁用状态
                        L1.BackColor = Color.Gray;  // 设置背景色为灰色
                        L1.Text = str;              // 设置显示文本
                        break;
                    case 6:  // 状态6：浅绿色背景，准备状态
                        L1.BackColor = Color.LightGreen;  // 设置背景色为浅绿色
                        L1.Text = str;                    // 设置显示文本
                        break;
                    case 7:  // 状态7：透明背景，默认状态
                        L1.BackColor = Color.Transparent; // 设置背景色为透明
                        L1.Text = str;                    // 设置显示文本
                        break;
                }
            });
        }

        // Label1更新方法 - 处理复杂文本显示，支持多行和父控件设置
        public void UpdateLabel1(Label L1, int Idex, string str, PictureBox PB)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 解析分号分隔的字符串为数组
                string[] result = str.Split(';');

                // 如果结果数组有16个元素（完整的数据包）
                if (result.Length == 16)
                {
                    // 为各个数据项添加描述性前缀
                    result[1] = "端子U处：" + result[1];    // 端子U温度/状态
                    result[2] = "端子V处：" + result[2];    // 端子V温度/状态
                    result[3] = "端子W处：" + result[3];    // 端子W温度/状态
                    result[4] = "螺丝1处：" + result[4];    // 螺丝1状态
                    result[5] = "螺丝2处：" + result[5];    // 螺丝2状态
                    result[6] = "电源端子处：" + result[6];  // 电源端子状态
                    result[7] = "螺丝3处：" + result[7];    // 螺丝3状态

                    result[8] = "区域1：" + result[8];      // 区域1状态
                    result[9] = "区域2：" + result[9];      // 区域2状态
                    result[10] = "区域3：" + result[10];    // 区域3状态
                    result[11] = "区域4：" + result[11];    // 区域4状态
                    result[12] = "区域5：" + result[12];    // 区域5状态
                    result[13] = "区域6：" + result[13];    // 区域6状态
                    result[14] = "区域7：" + result[14];    // 区域7状态
                    result[15] = "区域8：" + result[15];    // 区域8状态

                    // 重新组合为多行字符串
                    str = string.Join("\n", result);
                }

                switch (Idex)
                {
                    case 6:  // 状态6：绿色文本，正常状态
                             // 将分号替换为分号加换行，实现多行显示
                        L1.Text = str.Replace(";", ";\n");
                        L1.ForeColor = Color.Lime;        // 设置文本颜色为绿色
                        L1.Parent = PB;                  // 设置父控件为图片框
                        L1.Location = new Point(10, 6);  // 设置显示位置
                        break;

                    case 7:  // 状态7：红色文本，报警状态
                             // 将分号替换为分号加换行，实现多行显示
                        L1.Text = str.Replace(";", ";\n");
                        L1.ForeColor = Color.Red;         // 设置文本颜色为红色
                        L1.Parent = PB;                  // 设置父控件为图片框
                        L1.Location = new Point(10, 6);  // 设置显示位置
                        break;

                    case 8:  // 状态8：白色背景，普通显示
                        L1.Text = str;                   // 设置显示文本
                        L1.BackColor = Color.White;      // 设置背景色为白色
                        break;
                }
            });
        }

        // Label2更新方法 - 调用数据库操作更新Label显示
        public void UpdateLabel2(int Idex, int Station, Label TB, Label TB2)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 调用标准类中的数据库数字处理方法
                // 该方法会根据工位和索引更新对应的Label显示
                StandardLB.intBC_DatabaseNum0(Idex, Station, TB, TB2);
            });
        }

        // 更新ComboBox状态
        public void Update_comboBox(ComboBox CB, int Idex)
        {
            this.BeginInvoke((EventHandler)delegate
            {
                if (Idex == 0)
                {
                    CB.Enabled = false;
                }
                else
                {
                    CB.Enabled = true;
                }
            });
        }

        // 更新UI开关状态
        public void UpdateUISwitch(int Idex, UISwitch UI)
        {
            this.BeginInvoke((EventHandler)delegate
            {
                switch (Idex)
                {
                    case 0:
                        break;
                    case 1:
                        break;
                }
            });
        }

        // 更新列表框0
        public void UpdatelistBox0(string Str)
        {

            this.BeginInvoke((EventHandler)delegate
            {

                String A = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss   ") + Str;

                listBox1.Items.Add(A);
                listBox1.SelectedIndex = listBox1.Items.Count - 1;


                if (listBox1.Items.Count > 1000)
                {
                    listBox1.Items.Clear();
                }
            });
        }


        // 更新列表框1
        public void UpdatelistBox1(CheckBox CB, string Str1, string Str2)
        {

            this.BeginInvoke((EventHandler)delegate
            {
                if (CB.Checked)
                {
                    String A = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + Str1;
                    String B = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + Str2;

                    listBox2.Items.Add(A);
                    listBox2.SelectedIndex = listBox2.Items.Count - 1;

                    listBox3.Items.Add(B);
                    listBox3.SelectedIndex = listBox3.Items.Count - 1;

                    if (listBox2.Items.Count > 1000)
                    {
                        listBox2.Items.Clear();
                        listBox3.Items.Clear();
                    }
                }
            });
        }


        // 更新文本框
        public void UpdateTexBox(TextBox TB, string Str, int Idex)
        {
            this.BeginInvoke((EventHandler)delegate
            {
                StandardLB.UpdateTB(TB, Str, Idex);
            });
        }

         // 更新图片显示
        public void UpdateList17()
        {
            this.BeginInvoke((EventHandler)delegate
            {
                // DisPlay_Pie();
            });
        }

        // 更新列表16
        public void UpdateList16(int Idex)
        {
            this.BeginInvoke((EventHandler)delegate
            {

            });
        }


        // 更新图片显示方法 - 根据当前选中的标签页和PLC状态更新IO状态指示灯
        public void UpdatePic()
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 检查当前选中的标签页是否为第4个（索引3，监控界面）
                if (tabControl1.SelectedIndex == 3)
                {
                    // 更新各个IO状态对应的图片框显示
                    // 使用GetPictures_IO方法根据布尔状态设置图片颜色（绿色/红色）
                    GetPictures_IO(pictureBox89, StandardLB.State[0]);   // 状态0对应的IO
                    GetPictures_IO(pictureBox93, StandardLB.State[1]);   // 状态1对应的IO
                    GetPictures_IO(pictureBox95, StandardLB.State[2]);   // 状态2对应的IO
                    GetPictures_IO(pictureBox90, StandardLB.State[3]);   // 状态3对应的IO
                    GetPictures_IO(pictureBox88, StandardLB.State[4]);   // 状态4对应的IO
                    GetPictures_IO(pictureBox91, StandardLB.State[5]);   // 状态5对应的IO
                    GetPictures_IO(pictureBox96, StandardLB.State[6]);   // 状态6对应的IO
                    GetPictures_IO(pictureBox85, StandardLB.State[22]);  // 状态22对应的IO


                    GetPictures_IO(pictureBox65, StandardLB.State[7]);
                    GetPictures_IO(pictureBox66, StandardLB.State[8]);
                    GetPictures_IO(pictureBox68, StandardLB.State[9]);
                    GetPictures_IO(pictureBox71, StandardLB.State[10]);
                    GetPictures_IO(pictureBox70, StandardLB.State[11]);
                    GetPictures_IO(pictureBox69, StandardLB.State[12]);
                    GetPictures_IO(pictureBox82, StandardLB.State[13]);
                    GetPictures_IO(pictureBox83, StandardLB.State[14]);

                    GetPictures_IO(pictureBox81, StandardLB.State[15]);
                    GetPictures_IO(pictureBox76, StandardLB.State[16]);
                    GetPictures_IO(pictureBox80, StandardLB.State[17]);
                    GetPictures_IO(pictureBox78, StandardLB.State[18]);
                    GetPictures_IO(pictureBox72, StandardLB.State[19]);
                    GetPictures_IO(pictureBox73, StandardLB.State[20]);
                    GetPictures_IO(pictureBox64, StandardLB.State[21]);

                }
            });
        }


        // 更新IO状态显示方法 - 在IO监控界面显示PLC输入输出状态
        public void UpdateIO()
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 检查当前是否在IO监控标签页且PLC连接正常
                if (tabControl1.SelectedIndex == 1 && StandardLB.PLCState)
                {
                    // 更新PLC输入输出点的状态显示
                    // I0.0 - I0.7 输入点
                    GetPictures_IO(pictureBox4, StandardLB.PLC_TO_OPC[0]);  // I0.0  
                    GetPictures_IO(pictureBox6, StandardLB.PLC_TO_OPC[1]);  // I0.1
                    GetPictures_IO(pictureBox7, StandardLB.PLC_TO_OPC[2]);
                    GetPictures_IO(pictureBox8, StandardLB.PLC_TO_OPC[3]);
                    GetPictures_IO(pictureBox9, StandardLB.PLC_TO_OPC[4]);
                    GetPictures_IO(pictureBox10, StandardLB.PLC_TO_OPC[5]);
                    GetPictures_IO(pictureBox11, StandardLB.PLC_TO_OPC[6]);
                    GetPictures_IO(pictureBox12, StandardLB.PLC_TO_OPC[7]);
                    
                    // I1.0 - I1.5 输入点
                    GetPictures_IO(pictureBox20, StandardLB.PLC_TO_OPC[8]);  //I1.0     
                    GetPictures_IO(pictureBox19, StandardLB.PLC_TO_OPC[9]);
                    GetPictures_IO(pictureBox18, StandardLB.PLC_TO_OPC[10]);
                    GetPictures_IO(pictureBox17, StandardLB.PLC_TO_OPC[11]);
                    GetPictures_IO(pictureBox16, StandardLB.PLC_TO_OPC[12]);
                    GetPictures_IO(pictureBox13, StandardLB.PLC_TO_OPC[13]);

                    // I2.0 - I2.7 输入点
                    GetPictures_IO(pictureBox24, StandardLB.PLC_TO_OPC[16]);  //I2.0     
                    GetPictures_IO(pictureBox23, StandardLB.PLC_TO_OPC[17]);
                    GetPictures_IO(pictureBox22, StandardLB.PLC_TO_OPC[18]);
                    GetPictures_IO(pictureBox21, StandardLB.PLC_TO_OPC[19]);
                    GetPictures_IO(pictureBox15, StandardLB.PLC_TO_OPC[20]);
                    GetPictures_IO(pictureBox14, StandardLB.PLC_TO_OPC[21]);
                    GetPictures_IO(pictureBox3, StandardLB.PLC_TO_OPC[22]);
                    GetPictures_IO(pictureBox2, StandardLB.PLC_TO_OPC[23]);

                    // I3.0 - I3.7 输入点
                    GetPictures_IO(pictureBox32, StandardLB.PLC_TO_OPC[24]);  //I3.0     
                    GetPictures_IO(pictureBox31, StandardLB.PLC_TO_OPC[25]);
                    GetPictures_IO(pictureBox30, StandardLB.PLC_TO_OPC[26]);
                    GetPictures_IO(pictureBox29, StandardLB.PLC_TO_OPC[27]);
                    GetPictures_IO(pictureBox28, StandardLB.PLC_TO_OPC[28]);
                    GetPictures_IO(pictureBox27, StandardLB.PLC_TO_OPC[29]);
                    GetPictures_IO(pictureBox26, StandardLB.PLC_TO_OPC[30]);
                    GetPictures_IO(pictureBox25, StandardLB.PLC_TO_OPC[31]);

                    // Q0.0 - Q0.7 输出点
                    GetPictures_IO(pictureBox40, StandardLB.PLC_TO_OPC[32]);  // Q0.0     
                    GetPictures_IO(pictureBox39, StandardLB.PLC_TO_OPC[33]);  // Q0.1
                    GetPictures_IO(pictureBox38, StandardLB.PLC_TO_OPC[34]);
                    GetPictures_IO(pictureBox37, StandardLB.PLC_TO_OPC[35]);
                    GetPictures_IO(pictureBox36, StandardLB.PLC_TO_OPC[36]);
                    GetPictures_IO(pictureBox35, StandardLB.PLC_TO_OPC[37]);
                    GetPictures_IO(pictureBox34, StandardLB.PLC_TO_OPC[38]);
                    GetPictures_IO(pictureBox1, StandardLB.PLC_TO_OPC[39]);

                    // Q1.0 - Q1.1 输出点
                    GetPictures_IO(pictureBox41, StandardLB.PLC_TO_OPC[40]);  //Q1.0     
                    GetPictures_IO(pictureBox42, StandardLB.PLC_TO_OPC[41]);

                    // Q2.0 - Q2.7 输出点
                    GetPictures_IO(pictureBox43, StandardLB.PLC_TO_OPC[48]);  //Q2.0     
                    GetPictures_IO(pictureBox45, StandardLB.PLC_TO_OPC[49]);
                    GetPictures_IO(pictureBox47, StandardLB.PLC_TO_OPC[50]);
                    GetPictures_IO(pictureBox49, StandardLB.PLC_TO_OPC[51]);
                    GetPictures_IO(pictureBox50, StandardLB.PLC_TO_OPC[52]);
                    GetPictures_IO(pictureBox48, StandardLB.PLC_TO_OPC[53]);
                    GetPictures_IO(pictureBox46, StandardLB.PLC_TO_OPC[54]);
                    GetPictures_IO(pictureBox44, StandardLB.PLC_TO_OPC[55]);

                    // Q3.0 - Q3.7 输出点
                    GetPictures_IO(pictureBox51, StandardLB.PLC_TO_OPC[56]);  //Q3.0     
                    GetPictures_IO(pictureBox53, StandardLB.PLC_TO_OPC[57]);
                    GetPictures_IO(pictureBox55, StandardLB.PLC_TO_OPC[58]);
                    GetPictures_IO(pictureBox57, StandardLB.PLC_TO_OPC[59]);
                    GetPictures_IO(pictureBox58, StandardLB.PLC_TO_OPC[60]);
                    GetPictures_IO(pictureBox56, StandardLB.PLC_TO_OPC[61]);
                    GetPictures_IO(pictureBox54, StandardLB.PLC_TO_OPC[62]);
                    GetPictures_IO(pictureBox52, StandardLB.PLC_TO_OPC[63]);
                }
            });
        }


        // 保存图片方法 - 将图片框中的图片保存到指定路径
        public void Save_Picture(PictureBox PT, string Pathsave, string PathRead, int State, string Code)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 调用StandardLB类的图片处理方法
                StandardLB.PictureHandle(PT, Pathsave, PathRead, State, Code);
            });
        }


        // 删除图片方法 - 删除指定工位的图片文件
        public void Delet_Picture(int Station, PictureBox PB0)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                // 调用StandardLB类的删除文件方法
                StandardLB.Deleteflie(PB0, StandardLB.DeletPT[Station]);
            });
        }


        // 图表设置方法 - 配置Chart控件的显示属性
        public void ChartSet(Chart CT)
        {
            // 设置X轴显示的数据点数量为15个
            CT.ChartAreas["ChartArea1"].AxisX.ScaleView.Size = 15;          //x坐标显示的个数------------控制这个数量的大小进行缩放     
            CT.ChartAreas[0].AxisX.LabelStyle.IntervalType = DateTimeIntervalType.Seconds;   //设置x轴间隔值单位：秒
            CT.ChartAreas[0].AxisX.LabelStyle.Interval = 1;                 //设置X轴的值的间隔大小// 设置X轴值的间隔大小为1
            CT.ChartAreas[0].AxisX.LabelStyle.IsEndLabelVisible = false;    //是否在轴末尾显示标记// 不在轴末尾显示标记
            CT.ChartAreas[0].AxisX.LabelStyle.Format = "HH:mm:ss";          //设置X轴的数据样式// 设置X轴的数据显示格式为时分秒
            CT.ChartAreas[0].AxisX.ScaleView.MinSizeType = DateTimeIntervalType.Seconds;     // 设置X轴缩放的最小尺寸单位为秒
            CT.ChartAreas[0].AxisX.ScaleView.SizeType = DateTimeIntervalType.Seconds;        //度量单位// 设置X轴缩放的度量单位为秒
            CT.ChartAreas[0].AxisX.ScaleView.SmallScrollMinSize = 1;        // 设置小型滚动的最小尺寸
            CT.ChartAreas[0].AxisX.ScaleView.SmallScrollMinSizeType = DateTimeIntervalType.Seconds; // 设置小型滚动的尺寸类型为秒
            CT.ChartAreas[0].AxisX.IntervalType = DateTimeIntervalType.Seconds;              // 设置X轴间隔类型为秒
            CT.ChartAreas[0].AxisX.Enabled = AxisEnabled.True;              //将X轴始终展示
            CT.ChartAreas[0].AxisY.Enabled = AxisEnabled.True;              //将Y轴始终展示
            CT.ChartAreas[0].AxisX.MajorGrid.LineColor = Color.Gray;        //设置X轴网格线颜色   // 设置X轴网格线颜色为灰色
            CT.ChartAreas[0].AxisY.MajorGrid.LineColor = Color.Gray;        //设置Y轴网格线颜色   // 设置Y轴网格线颜色为灰色
            CT.ChartAreas[0].AxisX.ScrollBar.Enabled = false;               //关闭系统的滚动条，也可以不关闭，就可以滑动
            CT.Series[0].BorderWidth = 3;  //线宽
            CT.Series[1].BorderWidth = 3;  //线宽
            CT.Series[2].BorderWidth = 3;  //线宽


            CT.ChartAreas[0].CursorX.AutoScroll = true;        // 启用X轴自动滚动
            CT.ChartAreas[0].AxisX.ScrollBar.Enabled = true;   // 启用X轴滚动条
            // CT.ChartAreas[0].CursorX.IsUserEnabled = true;
            //  CT.ChartAreas[0].CursorX.IsUserSelectionEnabled = true;
            // CT.ChartAreas[0].AxisX.ScaleView.Zoomable = true;
            CT.ChartAreas[0].AxisX.ScaleView.Size = 8;         // 设置X轴缩放视图的大小为8个数据点 
        }


        // 更新图表方法 - 向图表中添加新的数据点
        private void UpdateChart(int Idex, int Station, Chart CT, CheckBox CB0)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                if (Idex == 1) // 添加数据点
                {
                    // 检查复选框是否被选中（是否显示图表）
                    if (CB0.Checked)
                    {
                        // 向3条数据序列添加新的数据点
                        CT.Series[0].Points.AddXY(DateTime.Now, StandardLB.Voltage[Station]);        // 系列0：电压数据
                        CT.Series[1].Points.AddXY(DateTime.Now, StandardLB.Current[Station]);        // 系列1：电流数据
                        CT.Series[2].Points.AddXY(DateTime.Now, StandardLB.Diff_pressure[Station]);  // 系列2：压差数据
                    }

                    try
                    {
                        // 如果X轴缩放视图大小大于0，则滚动到最后位置
                        if (CT.ChartAreas[0].AxisX.ScaleView.Size > 0)
                        {
                            CT.ChartAreas[0].AxisX.ScaleView.Scroll(System.Windows.Forms.DataVisualization.Charting.ScrollType.Last);
                        }
                    }
                    catch (Exception ex) { }   // 忽略滚动异常

                    // 获取图表中的总数据点数
                    int Count = GetTotalPointsInChart(CT);
                    // 如果数据点超过10000个，清空图表以避免内存问题
                    if (Count > 10000)
                    {
                        CT.Series[0].Points.Clear();  // 清空电压数据序列
                        CT.Series[1].Points.Clear();  // 清空电流数据序列
                        CT.Series[2].Points.Clear();  // 清空压差数据序列
                    }

                    // 强制垃圾回收，释放内存
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                    GC.Collect();
                }
                else if (Idex == 0)   // 清空图表
                {
                    // 清空所有数据序列的点
                    CT.Series[0].Points.Clear();  // 清空电压数据序列
                    CT.Series[1].Points.Clear();  // 清空电流数据序列
                    CT.Series[2].Points.Clear();  // 清空压差数据序列
                }
            });
        }


        // 获取图表中总点数方法 - 计算图表中所有序列的数据点总数
        private int GetTotalPointsInChart(Chart chart)
        {
            int totalPoints = 0;// 总点数计数器

            // 遍历图表中的所有数据序列
            foreach (Series series in chart.Series)
            {
                // 累加每个序列的数据点数量
                totalPoints += series.Points.Count;
            }
            return totalPoints;  // 返回总点数
        }


        // 获取数字和字母字符方法 - 从源字符串中提取字母和数字
        public static string GetNumberAlpha(string source)
        {
            string pattern = "[A-Za-z0-9]";   // 正则表达式模式：匹配字母和数字
            string strRet = "";               // 结果字符串
            // 使用正则表达式匹配所有字母和数字字符
            MatchCollection results = Regex.Matches(source, pattern);
            // 遍历匹配结果
            foreach (var v in results)
            {
                strRet += v.ToString();   // 将匹配的字符添加到结果字符串
            }
            return strRet;   // 返回只包含字母数字的字符串
        }



        #region //字节数组转16进制字符串
        /// <字节数组转16进制字符串>
        /// <param name="bytes"></param>
        /// <returns> String 16进制显示形式</returns>
        public static string byteToHexStr(byte[] bytes)
        {
            string returnStr = "";   // 返回的字符串
            try
            {
                if (bytes != null)   // 检查字节数组是否为空
                {
                    // 遍历字节数组中的每个字节
                    for (int i = 0; i < bytes.Length; i++)
                    {
                        returnStr += bytes[i].ToString("X2");
                        returnStr += " ";  //两个16进制用空格隔开,方便看数据
                    }
                }
                return returnStr;          // 返回16进制字符串
            }
            catch (Exception)
            {
                return returnStr;          // 发生异常时返回当前字符串
            }
        }

        /// <字符串转16进制格式,不够自动前面补零>
        /// 
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        private static byte[] strToToHexByte(String hexString)
        {
            int i;  // 循环计数器
            hexString = hexString.Replace(" ", "");   // 清除字符串中的空格
            // 检查字符串长度是否为奇数
            if ((hexString.Length % 2) != 0)          //奇数个
            {
                // 创建字节数组，长度为(字符串长度+1)/2
                byte[] returnBytes = new byte[(hexString.Length + 1) / 2];
                try
                {
                    // 处理前n-1个字节
                    for (i = 0; i < (hexString.Length - 1) / 2; i++)
                    {
                        // 每2个字符转换为一个字节
                        returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
                    }
                    // 处理最后一个字节，前面补零
                    returnBytes[returnBytes.Length - 1] = Convert.ToByte(hexString.Substring(hexString.Length - 1, 1).PadLeft(2, '0'), 16);
                }
                catch
                {
                    MessageBox.Show("含有非16进制字符", "提示");  // 显示错误提示
                    return null;     // 返回空
                }
                return returnBytes;  // 返回字节数组
            }
            else  // 偶数个字符
            {
                  // 创建字节数组，长度为字符串长度的一半
                byte[] returnBytes = new byte[(hexString.Length) / 2];
                try
                {
                    // 遍历所有字节
                    for (i = 0; i < returnBytes.Length; i++)
                    {
                        // 每2个字符转换为一个字节
                        returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
                    }
                }
                catch
                {
                    MessageBox.Show("含有非16进制字符", "提示");   // 显示错误提示
                    return null;     // 返回空
                }
                return returnBytes;  // 返回字节数组
            }
        }


        /// <summary>
        /// ASCII码转字符
        /// </summary>
        /// <param name="asciiCode"></param>
        /// <returns></returns>
        public static string Chr(int asciiCode)
        {
            // 检查ASCII码是否在有效范围内(0-255)
            if (asciiCode >= 0 && asciiCode <= 255)
            {
                // 创建ASCII编码器
                System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
                // 创建包含ASCII码的字节数组
                byte[] byteArray = new byte[] { (byte)asciiCode };
                // 将字节数组转换为字符串
                string strCharacter = asciiEncoding.GetString(byteArray);
                return (strCharacter);    // 返回字符
            }
            else
            {
                throw new Exception("ASCII Code is not valid.");  // 抛出异常
            }
        }

        #endregion
        // 列表视图更新方法 - 更新ListView控件的内容
        public void ListView_Updata(ListView LV, int Idex, string[] Str0)
        {
            // 使用BeginInvoke确保在UI线程上执行
            this.BeginInvoke((EventHandler)delegate
            {
                try
                {
                    if (Idex == 1)         // 添加数据
                    {
                        LV.BeginUpdate();  //数据更新，UI暂时挂起，直到EndUpdate绘制控件，可以有效避免闪烁并大大提高加载速度 
                        
                        // 创建新的列表项
                        ListViewItem list0 = new ListViewItem();
                        //ListViewItem list1 = new ListViewItem();
                        //ListViewItem list2 = new ListViewItem();
                        //ListViewItem list3 = new ListViewItem();
                        //ListViewItem list4 = new ListViewItem();
                        //ListViewItem list5 = new ListViewItem();
                        //ListViewItem list6 = new ListViewItem();
                        //ListViewItem list7 = new ListViewItem();
                        //ListViewItem list8 = new ListViewItem();
                        //ListViewItem list9 = new ListViewItem();

                        // 设置列表项的各个列的值
                        list0.Text = Str0[0];           // 第一列（主列）
                        list0.SubItems.Add(Str0[1]);    //第二列
                        list0.SubItems.Add(Str0[1]);    // 第二列
                        list0.SubItems.Add(Str0[2]);    // 第三列
                        list0.SubItems.Add(Str0[3]);    // 第四列
                        list0.SubItems.Add(Str0[4]);    // 第五列
                        list0.SubItems.Add(Str0[5]);    // 第六列
                        list0.SubItems.Add(Str0[6]);    // 第七列
                        list0.SubItems.Add(Str0[7]);    // 第八列
                        list0.SubItems.Add(Str0[8]);    // 第九列
                        list0.SubItems.Add(Str0[9]);    // 第十列
                        list0.SubItems.Add(Str0[10]);   // 第十一列

                        // 将列表项添加到ListView
                        LV.Items.Add(list0);


                        for (int i = 0; i < LV.Items.Count; i++)
                        {
                            if (i % 2 == 0)
                            {
                                LV.Items[i].BackColor = SystemColors.ActiveCaption;
                            }
                        }

                        LV.EndUpdate(); //结束数据处理，UI界面一次性绘制。
                    }
                    else
                    {
                        LV.Items.Clear();
                    }
                }
                catch (Exception ex)
                { }
            });
        }


        // 按钮1点击事件 - 执行数据库操作（索引0对应的操作）
        private void button1_Click(object sender, EventArgs e)
        {
            StandardLB.BC_DatabaseOperation(0);  // 调用标准类中的数据库操作方法，参数0表示特定操作类型
        }

        // 按钮2点击事件 - 执行数据库操作（索引3对应的操作）
        private void button2_Click(object sender, EventArgs e)
        {
            StandardLB.BC_DatabaseOperation(3);  // 执行数据库操作，可能是查询或更新
        }

        // 按钮4点击事件 - 执行数据库操作（索引1对应的操作）
        private void button4_Click(object sender, EventArgs e)
        {
            StandardLB.BC_DatabaseOperation(1);  // 执行数据库操作，可能是插入或删除
        }

        // 按钮5点击事件 - 参数设置完成提示
        private void button5_Click(object sender, EventArgs e)
        {
            try
            {
                MessageBox.Show("参数设置完成", "提示信息", MessageBoxButtons.OK);  // 显示参数设置成功提示
            }
            catch (Exception)
            {
                MessageBox.Show("参数设置失败", "提示信息", MessageBoxButtons.OKCancel);  // 异常时显示失败提示
            }
        }

        // 按钮10点击事件 - 密码更新操作
        private void button10_Click(object sender, EventArgs e)
        {
            try
            {
                // 注释掉的数据库更新代码：sql1.UpdataDtata5("QmlData", "ParameterSetTable", Parameter[12], Parameter[13], Parameter[22]);
                MessageBox.Show("密码更新完成", "提示信息", MessageBoxButtons.YesNo);  // 显示密码更新完成提示
            }
            catch (Exception)
            {
                MessageBox.Show("密码更新失败", "提示信息", MessageBoxButtons.YesNo);  // 异常时显示失败提示
            }
        }

        // 按钮11点击事件 - 创建数据库表（注释掉的代码）
        private void button11_Click(object sender, EventArgs e)
        {
            // 注释掉的创建表代码：sql1.CreateDataTable6("QmlData", "LoginTable");
        }

        // 按钮9点击事件 - 创建新配方
        private void button9_Click_2(object sender, EventArgs e)
        {
            NewRecipe();  // 调用新建配方方法
        }

        // 按钮12点击事件 - 删除配方数据
        private void button12_Click(object sender, EventArgs e)
        {
            SQLControlVlalue(5);  // 参数5表示删除配方操作
        }

        // 按钮5点击事件（重载）- 更新配方参数
        private void button5_Click_1(object sender, EventArgs e)
        {
            try
            {
                SQLControlVlalue(2);  // 参数2表示更新配方参数
                SQLControlVlalue(3);  // 参数3表示读取配方参数
                MessageBox.Show("参数设置完成", "提示信息", MessageBoxButtons.OK);  // 显示设置完成提示
            }
            catch (Exception)
            {
                MessageBox.Show("参数设置失败", "提示信息", MessageBoxButtons.YesNo);  // 异常时显示失败提示
            }
        }

        // 按钮17点击事件 - 创建新配方
        private void button17_Click(object sender, EventArgs e)
        {
            NewRecipe();  // 调用新建配方方法
        }

        // 按钮21点击事件 - 向数据库插入测试数据
        private void button21_Click(object sender, EventArgs e)
        {
            DataTime = System.DateTime.Now.ToString("G");  // 获取当前日期时间
                                                           // 向数据库插入测试数据，包含时间、条码、工位、各种测试参数和结果
            StandardLB.SQL1.InsertData(DataTime, "rrrrrrr", "左工位", "6", "34", "56", "NG");
        }

        // 按钮23点击事件 - 空实现
        private void button23_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮22点击事件 - 空实现
        private void button22_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 组合框2选择改变事件 - 读取配方参数
        private void comboBox2_SelectedIndexChanged(object sender, EventArgs e)
        {
            SQLControlVlalue(3);  // 参数3表示读取配方参数
        }

        // 按钮21点击事件（重载）- 设置按钮状态
        private void button21_Click_1(object sender, EventArgs e)
        {
            StandardLB.BTNState[0] = 1;  // 设置按钮状态数组的第一个元素为1（激活状态）
        }

        // 按钮24点击事件 - 空实现
        private void button24_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮28点击事件 - 空实现
        private void button28_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮29点击事件 - 创建数据库
        private void button29_Click(object sender, EventArgs e)
        {
            StandardLB.SQL1.CreateDataBase("QmlData");  // 创建名为"QmlData"的数据库
        }

        // 按钮30点击事件 - 执行数据库操作（索引1对应的操作）
        private void button30_Click(object sender, EventArgs e)
        {
            StandardLB.BC_DatabaseOperation(1);  // 执行数据库操作
        }

        // 按钮31点击事件 - 执行数据库操作（索引3对应的操作）
        private void button31_Click(object sender, EventArgs e)
        {
            StandardLB.BC_DatabaseOperation(3);  // 执行数据库操作
        }

        // 按钮25点击事件 - 更新并读取配方参数
        private void button25_Click(object sender, EventArgs e)
        {
            try
            {
                SQLControlVlalue(2);  // 参数2表示更新配方参数
                SQLControlVlalue(3);  // 参数3表示读取配方参数
                MessageBox.Show("参数设置完成", "提示信息", MessageBoxButtons.OK);  // 显示设置完成提示
            }
            catch (Exception ex)
            {
                MessageBox.Show("参数设置失败", "提示信息", MessageBoxButtons.YesNo);  // 异常时显示失败提示
            }
        }

        // 按钮26点击事件 - 创建新配方
        private void button26_Click(object sender, EventArgs e)
        {
            NewRecipe();  // 调用新建配方方法
        }

        // 组合框1选择改变事件 - 配方选择变化处理
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            SQLControlVlalue(3);  // 读取选中的配方参数
                                  // 注释掉的TCP发送代码：TcpSend("PW," + StandardLB.RecipeParameter[3]);
            StandardLB.ProInt = 1;  // 设置产品标识为1
        }

        // 文本框3按键事件 - 只允许输入数字和退格键
        private void textBox3_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 只允许输入退格键(8)和数字(48-57)
            if (!(e.KeyChar == 8 || (e.KeyChar >= 48 && e.KeyChar <= 57)))
            {
                e.Handled = true;  // 阻止非法字符输入
            }
        }

        // 按钮32点击事件 - 空实现
        private void button32_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮27点击事件 - 删除配方
        private void button27_Click(object sender, EventArgs e)
        {
            SQLControlVlalue(5);  // 参数5表示删除配方操作
        }

        // 按钮33点击事件 - 空实现
        private void button33_Click(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮35点击事件 - 设置按钮状态
        private void button35_Click(object sender, EventArgs e)
        {
            StandardLB.BTNState[1] = 1;  // 设置按钮状态数组的第二个元素为1（激活状态）
        }

        // 按钮21点击事件（重载）- 空实现
        private void button21_Click_2(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 文本框44按键事件 - 只允许输入数字和退格键
        private void textBox44_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 只允许输入数字和退格键，其他字符转换为空字符
            if ((e.KeyChar != 8 && !char.IsDigit(e.KeyChar)))
            {
                e.KeyChar = Convert.ToChar(0);  // 将非法字符转换为空字符
            }
        }

        // 数据收集方法 - 根据索引收集或清空测试数据
        private void CollectData(int Idex)
        {
            if (Idex == 1)  // 收集数据模式
            {
                // 将当前测试数据添加到对应的列表中
                StandardLB.Voltage0.Add(StandardLB.Voltage[0]);           // 添加电压数据
                StandardLB.CurrentList0.Add(StandardLB.Current[0]);       // 添加电流数据
                StandardLB.CollectFlowList0.Add(StandardLB.Flow[0]);      // 添加流量数据
                StandardLB.CountLift0.Add(StandardLB.YC_Lift);            // 添加扬程数据
                StandardLB.PressureDiffList0.Add(StandardLB.Pressure_Diff); // 添加压差数据
                StandardLB.InPressureList0.Add(StandardLB.Input_pressure[0]); // 添加输入压力数据

                // 根据参数决定是否收集温度数据
                if (StandardLB.Parameterfloat[87] == 1)
                {
                    StandardLB.TemperatureList.Add(StandardLB.Temperature[0]);  // 添加温度数据
                }
                else
                {
                    StandardLB.TemperatureList.Add(0);  // 添加0值温度数据
                }

                // 继续添加其他测试数据
                StandardLB.InputPower0.Add(StandardLB.IN_Power);      // 添加输入功率数据
                StandardLB.OutPower0.Add(StandardLB.OUT_Power);       // 添加输出功率数据
                StandardLB.MotorRatio0.Add(StandardLB.XL_ratio);      // 添加电机转速比例数据
            }
            else  // 清空数据模式
            {
                // 清空所有数据列表
                StandardLB.Voltage0.Clear();           // 清空电压数据列表
                StandardLB.CurrentList0.Clear();       // 清空电流数据列表
                StandardLB.CollectFlowList0.Clear();   // 清空流量数据列表
                StandardLB.CountLift0.Clear();         // 清空扬程数据列表
                StandardLB.PressureDiffList0.Clear();  // 清空压差数据列表
                StandardLB.InPressureList0.Clear();    // 清空输入压力数据列表
                StandardLB.TemperatureList.Clear();    // 清空温度数据列表
                StandardLB.InputPower0.Clear();        // 清空输入功率数据列表
                StandardLB.OutPower0.Clear();         // 清空输出功率数据列表
                StandardLB.MotorRatio0.Clear();       // 清空电机转速比例数据列表
            }
        }

        // 按钮24点击事件（重载）- 空实现
        private void button24_Click_1(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮23点击事件（重载）- 导出数据到Excel
        private void button23_Click_1(object sender, EventArgs e)
        {
            // 准备导出数据的字符串数组
            string[] Str = new string[8];
            Str[0] = StandardLB.RecipeParameter[30];  // 产品参数1
            Str[1] = StandardLB.RecipeParameter[31];  // 产品参数2
            Str[2] = StandardLB.RecipeParameter[32];  // 产品参数3
            Str[3] = StandardLB.RecipeParameter[33];  // 产品参数4
            Str[4] = StandardLB.RecipeParameter[34];  // 产品参数5
            Str[5] = StandardLB.RecipeParameter[35];  // 产品参数6
            Str[6] = StandardLB.RecipeParameter[36];  // 产品参数7
            Str[7] = System.DateTime.Now.ToString("G");  // 当前时间

            // 调用数据导出方法，将所有收集的数据导出到Excel
            StandardLB.DataToExcel(Str, StandardLB.Voltage0, StandardLB.CurrentList0, StandardLB.CollectFlowList0, StandardLB.CountLift0, StandardLB.PressureDiffList0,
                StandardLB.InPressureList0, StandardLB.TemperatureList, StandardLB.InputPower0, StandardLB.OutPower0, StandardLB.MotorRatio0);
        }

        // 组合框3选择改变事件 - 空实现
        private void comboBox3_SelectedIndexChanged(object sender, EventArgs e)
        {
            // 空方法，暂无功能实现
        }

        // 按钮21点击事件（重载）- 设置电源电压
        private void button21_Click_3(object sender, EventArgs e)
        {
            PowerStrTr(1, textBox122.Text);  // 调用电源字符串转换方法，参数1表示发送命令，textBox122.Text为电压值
        }

        // 文本框116按键事件 - 只允许输入数字和退格键
        private void textBox116_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框119按键事件 - 只允许输入数字和退格键
        private void textBox119_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框120按键事件 - 只允许输入数字和退格键
        private void textBox120_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框121按键事件 - 只允许输入数字和退格键
        private void textBox121_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框118按键事件 - 只允许输入数字和退格键
        private void textBox118_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框117按键事件 - 只允许输入数字和退格键
        private void textBox117_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 按钮33点击事件（重载）- 更新操作员数据
        private void button33_Click_1(object sender, EventArgs e)
        {
            try
            {
                StandardLB.SQlOp(0);  // 执行SQL操作，参数0表示更新操作员数据

                // 定义操作员姓名和ID的文件路径
                string Name1 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "name.txt");
                string ID1 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ID.txt");

                // 将操作员数据写入文件
                File.WriteAllLines(Name1, StandardLB.SQL1.OPName);  // 写入操作员姓名
                File.WriteAllLines(ID1, StandardLB.SQL1.OPID);      // 写入操作员ID

                MessageBox.Show("更新完成", "提示信息", MessageBoxButtons.YesNo);  // 显示更新完成提示
            }
            catch (Exception)
            {
                MessageBox.Show("远程数据库连接失败，请检测网络或无线网卡", "提示信息", MessageBoxButtons.YesNo);  // 显示连接失败提示
            }
        }

        // 文本框130按键事件 - 只允许输入数字和退格键
        private void textBox130_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框113按键事件 - 只允许输入数字和退格键
        private void textBox113_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框59按键事件 - 只允许输入数字和退格键
        private void textBox59_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框133按键事件 - 空实现（允许所有输入）
        private void textBox133_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 空方法，不限制输入内容
        }

        // 文本框132按键事件 - 只允许输入数字和退格键
        private void textBox132_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 文本框131按键事件 - 只允许输入数字和退格键
        private void textBox131_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')  // 允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))  // 只允许输入0-9数字
                {
                    e.Handled = true;  // 阻止非法字符输入
                }
            }
        }

        // 按钮24点击事件（重载）- 停止电源
        private void button24_Click_2(object sender, EventArgs e)
        {
            ProPower1(StandardLB.Power_Stop);  // 发送电源停止命令
        }

        // UI开关1状态改变事件 - 工位1电源开关状态处理
        private void uiSwitch1_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[0].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[0], 2);  // 设置工位1状态指示灯为灰色（待机状态）
            }
        }

        // UI开关4状态改变事件 - 工位2电源开关状态处理
        private void uiSwitch4_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[1].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[1], 2);  // 设置工位2状态指示灯为灰色（待机状态）
            }
        }

        // UI开关5状态改变事件 - 工位3电源开关状态处理
        private void uiSwitch5_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[2].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[2], 2);  // 设置工位3状态指示灯为灰色（待机状态）
            }
        }

        // UI开关7状态改变事件 - 工位4电源开关状态处理
        private void uiSwitch7_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[3].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[3], 2);  // 设置工位4状态指示灯为灰色（待机状态）
            }
        }

        // UI开关8状态改变事件 - 工位5电源开关状态处理
        private void uiSwitch8_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[4].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[4], 2);  // 设置工位5状态指示灯为灰色（待机状态）
            }
        }

        // UI开关10状态改变事件 - 工位6电源开关状态处理
        private void uiSwitch10_ActiveChanged(object sender, EventArgs e)
        {
            if (!UIStart[5].Active)  // 如果开关处于非激活状态（关闭）
            {
                GetPictures1(PB_State[5], 2);  // 设置工位6状态指示灯为灰色（待机状态）
            }
        }

        // UI开关29状态改变事件 - 处理中英文界面切换
        private void uiSwitch29_ActiveChanged(object sender, EventArgs e)
        {
            // 检查开关是否处于非激活状态（中文界面）
            if (!uiSwitch29.Active)
            {
                // === 中文界面设置 ===

                // 设置窗体标题和主标题
                this.Text = "飞龙电子技术研究院";
                label19.Text = "电 子 水 泵 耐 久 测 试 台";

                // 设置各标签页的中文标题
                tabPage1.Text = "耐久测试";
                tabPage3.Text = "手动界面";
                tabPage2.Text = "曲线监控";
                tabPage7.Text = "监控界面";
                tabPage5.Text = "运行日志";
                tabPage4.Text = "设置界面";

                // 设置各工位标签的中文文本
                label8.Text = "测试方式";
                label106.Text = "测试方式";
                label126.Text = "测试方式";
                label134.Text = "测试方式";
                label142.Text = "测试方式";
                label150.Text = "测试方式";

                label9.Text = "运行时间";
                label107.Text = "运行时间";
                label127.Text = "运行时间";
                label135.Text = "运行时间";
                label143.Text = "运行时间";
                label151.Text = "运行时间";

                // 设置参数标签的中文文本
                label101.Text = "电压";
                label109.Text = "电压";
                label129.Text = "电压";
                label137.Text = "电压";
                label145.Text = "电压";
                label153.Text = "电压";

                label103.Text = "电流";
                label120.Text = "电流";
                label131.Text = "电流";
                label139.Text = "电流";
                label147.Text = "电流";
                label155.Text = "电流";

                label102.Text = "输入功率";
                label116.Text = "输入功率";
                label130.Text = "输入功率";
                label138.Text = "输入功率";
                label146.Text = "输入功率";
                label154.Text = "输入功率";

                label11.Text = "入口压力";
                label108.Text = "入口压力";
                label128.Text = "入口压力";
                label136.Text = "入口压力";
                label144.Text = "入口压力";
                label152.Text = "入口压力";

                label6.Text = "出口压力";
                label105.Text = "出口压力";
                label122.Text = "出口压力";
                label133.Text = "出口压力";
                label141.Text = "出口压力";
                label149.Text = "出口压力";

                label104.Text = "压差";
                label7.Text = "压差";
                label121.Text = "压差";
                label132.Text = "压差";
                label140.Text = "压差";
                label148.Text = "压差";

                label161.Text = "流量";
                label175.Text = "流量";
                label176.Text = "流量";
                label177.Text = "流量";
                label178.Text = "流量";
                label179.Text = "流量";

                // 设置标签位置（中文界面布局）
                label101.Location = new Point(285, 18);  // 电压标签位置
                label109.Location = new Point(285, 18);
                // ... 其他标签位置设置

                // 设置分组框中文文本
                groupBox11.Text = "设备信息";
                groupBox13.Text = "其他监控";

                // 设置操作员信息标签中文文本
                label211.Text = "作业员工号:";
                label215.Text = "作业员姓名:";
                OP_ID = "作业员工号:";
                OP_Name = "作业员姓名:";

                // 设置条码标签中文文本
                label207.Text = "OP1#条码";
                label203.Text = "OP2#条码";
                label205.Text = "OP3#条码";
                label208.Text = "OP4#条码";
                label214.Text = "OP5#条码";
                label239.Text = "OP6#条码";

                // 设置温度标签中文文本
                label159.Text = "主液罐温度";

                // 设置工位状态标签中文文本
                label15.Text = "OP1工位状态";
                label168.Text = "OP2工位状态";
                label169.Text = "OP3工位状态";
                label189.Text = "OP4工位状态";
                label190.Text = "OP5工位状态";
                label191.Text = "OP6工位状态";

                // 设置按钮中文文本
                button21.Text = "设置电压";

                // 从配方参数读取并设置测试模式显示文本
                textBox6.Text = StandardLB.RecipeParameter[10];
                textBox28.Text = StandardLB.RecipeParameter[11];
                textBox57.Text = StandardLB.RecipeParameter[12];
                textBox67.Text = StandardLB.RecipeParameter[13];
                textBox75.Text = StandardLB.RecipeParameter[14];
                textBox86.Text = StandardLB.RecipeParameter[15];

                // 设置各工位开关的中文文本
                uiSwitch1.InActiveText = "1#泵断电";
                uiSwitch1.ActiveText = "1#泵上电";
                uiSwitch4.InActiveText = "2#泵断电";
                uiSwitch4.ActiveText = "2#泵上电";
                uiSwitch5.InActiveText = "3#泵断电";
                uiSwitch5.ActiveText = "3#泵上电";
                uiSwitch7.InActiveText = "4#泵断电";
                uiSwitch7.ActiveText = "4#泵上电";
                uiSwitch8.InActiveText = "5#泵断电";
                uiSwitch8.ActiveText = "5#泵上电";
                uiSwitch10.InActiveText = "6#泵断电";
                uiSwitch10.ActiveText = "6#泵上电";

                // 设置其他标签中文文本
                label167.Text = "主液罐设定温度(°C)";
                label266.Text = "入口压力合格区间(kPa)";
                label259.Text = "额定转速(rpm)";
                label160.Text = "下限";

                // 加载中文报警信息文件
                string AM = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Alarm.txt");
                StandardLB.Alarm = File.ReadAllLines(AM);
            }
            // 检查开关是否处于激活状态（英文界面）
            else if (uiSwitch29.Active)
            {
                // === 英文界面设置 ===

                // 设置窗体标题和主标题（英文）
                this.Text = "Wuhu Feilong Automobile Electronic Research Institute  Co., Ltd.";
                label19.Text = "Electronic Water Pump Durability Equipment";

                // 设置各标签页的英文标题
                tabPage1.Text = "DurableTest";
                tabPage3.Text = "Manual";
                tabPage2.Text = "Curve";
                tabPage7.Text = "Monitoring";
                tabPage5.Text = "log";
                tabPage4.Text = "Settings";

                // 设置各工位标签的英文文本
                label8.Text = "Test Mode";
                label106.Text = "Test Mode";
                label126.Text = "Test Mode";
                label134.Text = "Test Mode";
                label142.Text = "Test Mode";
                label150.Text = "Test Mode";

                label9.Text = "Run Time";
                label107.Text = "Run Time";
                label127.Text = "Run Time";
                label135.Text = "Run Time";
                label143.Text = "Run Time";
                label151.Text = "Run Time";

                // 设置参数标签的英文文本
                label101.Text = "Voltage";
                label109.Text = "Voltage";
                label129.Text = "Voltage";
                label137.Text = "Voltage";
                label145.Text = "Voltage";
                label153.Text = "Voltage";

                label103.Text = "Current";
                label120.Text = "Current";
                label131.Text = "Current";
                label139.Text = "Current";
                label147.Text = "Current";
                label155.Text = "Current";

                label102.Text = "InputPower";
                label116.Text = "InputPower";
                label130.Text = "InputPower";
                label138.Text = "InputPower";
                label146.Text = "InputPower";
                label154.Text = "InputPower";

                label11.Text = "Inpressure";
                label108.Text = "Inpressure";
                label128.Text = "Inpressure";
                label136.Text = "Inpressure";
                label144.Text = "Inpressure";
                label152.Text = "Inpressure";

                label6.Text = "Outpressure";
                label105.Text = "Outpressure";
                label122.Text = "Outtpressure";
                label133.Text = "Outppressure";
                label141.Text = "Outtpressure";
                label149.Text = "Outpressure";

                label104.Text = "DiffPressure";
                label7.Text = "DiffPressure";
                label121.Text = "DiffPressure";
                label132.Text = "DiffPressure";
                label140.Text = "DiffPressure";
                label148.Text = "DiffPressure";

                label161.Text = "Flowmeter";
                label175.Text = "Flowmeter";
                label176.Text = "Flowmeter";
                label177.Text = "Flowmeter";
                label178.Text = "Flowmeter";
                label179.Text = "Flowmeter";

                // 设置标签位置（英文界面布局，因英文文本长度不同需要调整位置）
                label101.Location = new Point(270, 18);  // 电压标签位置调整
                label109.Location = new Point(270, 18);
                // ... 其他标签位置调整

                // 设置操作员信息标签英文文本
                label211.Text = "Operator ID:";
                label215.Text = "Operator Name:";
                OP_ID = "Operator ID:";
                OP_Name = "Operator Name:";

                // 设置条码标签英文文本
                label207.Text = "1#BarCode";
                label203.Text = "2#BarCode";
                label205.Text = "3#BarCode";
                label208.Text = "4#BarCode";
                label214.Text = "5#BarCode";
                label239.Text = "6#BarCode";

                // 设置分组框英文文本
                groupBox11.Text = "Equipment Information";
                groupBox13.Text = "Other monitoring";

                // 设置温度标签英文文本
                label159.Text = "Temperature";

                // 设置工位状态标签英文文本
                label15.Text = "OP1_State";
                label168.Text = "OP2_State";
                label169.Text = "OP3_State";
                label189.Text = "OP4_State";
                label190.Text = "OP5_State";
                label191.Text = "OP6_State";

                // 设置按钮英文文本
                button21.Text = "SetVoltage";

                // 从配方参数读取并翻译测试模式显示文本
                textBox6.Text = StandardLB.RecipeParameter[10];
                textBox28.Text = StandardLB.RecipeParameter[11];
                textBox57.Text = StandardLB.RecipeParameter[12];
                textBox67.Text = StandardLB.RecipeParameter[13];
                textBox75.Text = StandardLB.RecipeParameter[14];
                textBox86.Text = StandardLB.RecipeParameter[15];

                // 将中文测试模式名称翻译为英文
                if (StandardLB.RecipeParameter[10] == "耐久测试")
                {
                    textBox6.Text = "Durability Test";
                }
                else if (StandardLB.RecipeParameter[10] == "启停模式1")
                {
                    textBox6.Text = "Start Stop Test 1";
                }
                // ... 其他测试模式的翻译

                // 设置各工位开关的英文文本
                uiSwitch1.InActiveText = "1#Power off";
                uiSwitch1.ActiveText = "1#Power on";
                uiSwitch4.InActiveText = "2#Power off";
                uiSwitch4.ActiveText = "2#Power on";
                uiSwitch5.InActiveText = "3#Power off";
                uiSwitch5.ActiveText = "3#Power on";
                uiSwitch7.InActiveText = "4#Power off";
                uiSwitch7.ActiveText = "4#Power on";
                uiSwitch8.InActiveText = "5#Power off";
                uiSwitch8.ActiveText = "5#Power on";
                uiSwitch10.InActiveText = "6#Power off";
                uiSwitch10.ActiveText = "6#Power on";

                // 加载英文报警信息文件
                string AM = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Alarm_English.txt");
                StandardLB.Alarm = File.ReadAllLines(AM);
            }
        }

        // 设置工位1转速按钮点击事件
        private void button22_Click_1(object sender, EventArgs e)
        {
            try
            {
                // 计算转速百分比：(设定转速/额定转速)*100
                // textBox116.Text: 工位1设定的转速值
                // StandardLB.Parameterfloat[280]: 额定转速参数
                float S = 100 * float.Parse(textBox116.Text) / StandardLB.Parameterfloat[280];

                // 设置工位0（索引0）的LIN数据缓冲区，参数4表示转速控制
                StandardLB.LIN_DataBufferSet(0, 4, S);
            }
            catch (Exception ex)
            {
                // 异常处理：转速设置失败
                // 在实际应用中可能需要记录日志或显示错误信息
            }
        }

        // 设置工位2转速按钮点击事件
        private void button23_Click_2(object sender, EventArgs e)
        {
            try
            {
                // 计算工位2转速百分比
                // textBox134.Text: 工位2设定的转速值
                float S = 100 * float.Parse(textBox134.Text) / StandardLB.Parameterfloat[280];

                // 设置工位1（索引1）的LIN数据缓冲区
                StandardLB.LIN_DataBufferSet(1, 4, S);
            }
            catch (Exception ex)
            {
                // 异常处理
            }
        }

        // 设置工位3转速按钮点击事件
        private void button24_Click_3(object sender, EventArgs e)
        {
            try
            {
                // 计算工位3转速百分比
                // textBox135.Text: 工位3设定的转速值
                float S = 100 * float.Parse(textBox135.Text) / StandardLB.Parameterfloat[280];

                // 设置工位2（索引2）的LIN数据缓冲区
                StandardLB.LIN_DataBufferSet(2, 4, S);
            }
            catch (Exception ex)
            {
                // 异常处理
            }
        }
        // 按钮29点击事件处理 - 设置工位3的LIN转速
        private void button29_Click_1(object sender, EventArgs e)
        {
            try
            {
                // 计算转速百分比：(设定转速 / 额定转速) × 100
                // textBox189.Text: 用户输入的设定转速值
                // StandardLB.Parameterfloat[280]: 额定转速参数值
                float S = 100 * float.Parse(textBox189.Text) / StandardLB.Parameterfloat[280];

                // 设置LIN数据缓冲区：工位3，参数4(转速)，计算得到的百分比值
                StandardLB.LIN_DataBufferSet(3, 4, S);
            }
            catch (Exception ex)
            {
                // 捕获并忽略异常，防止程序崩溃
                // 实际应用中应考虑记录日志或提示用户
            }
        }

        // 按钮30点击事件处理 - 设置工位4的LIN转速
        private void button30_Click_1(object sender, EventArgs e)
        {
            try
            {
                // 计算转速百分比：(设定转速 / 额定转速) × 100
                // textBox190.Text: 用户输入的设定转速值
                float S = 100 * float.Parse(textBox190.Text) / StandardLB.Parameterfloat[280];

                // 设置LIN数据缓冲区：工位4，参数4(转速)，计算得到的百分比值
                StandardLB.LIN_DataBufferSet(4, 4, S);
            }
            catch (Exception ex)
            {
                // 异常处理：静默失败，不干扰用户操作
            }
        }

        // 按钮28点击事件处理 - 设置工位5的LIN转速
        private void button28_Click_1(object sender, EventArgs e)
        {
            try
            {
                // 计算转速百分比：(设定转速 / 额定转速) × 100
                // textBox188.Text: 用户输入的设定转速值
                float S = 100 * float.Parse(textBox188.Text) / StandardLB.Parameterfloat[280];

                // 设置LIN数据缓冲区：工位5，参数4(转速)，计算得到的百分比值
                StandardLB.LIN_DataBufferSet(5, 4, S);
            }
            catch (Exception ex)
            {
                // 异常处理：防止无效输入导致程序崩溃
            }
        }

        // 按钮31点击事件处理 - 空实现，预留功能扩展
        private void button31_Click_1(object sender, EventArgs e)
        {
            // 当前为空实现，可用于未来功能扩展
            // 在界面设计中可能已布局但尚未实现具体功能
        }

        // 标签页4点击事件处理 - 设置界面标签页点击响应
        private void tabPage4_Click(object sender, EventArgs e)
        {
            // 当前为空实现
            // 可用于设置界面的特定点击逻辑，如刷新数据或验证输入
        }

        // 标签271点击事件处理 - 界面标签点击响应
        private void label271_Click(object sender, EventArgs e)
        {
            // 当前为空实现
            // 可能用于显示帮助信息或触发特定界面操作
        }

        // 标签310点击事件处理 - 界面标签点击响应
        private void label310_Click(object sender, EventArgs e)
        {
            // 当前为空实现
            // 可能用于显示详细信息或切换显示模式
        }

        // 温度文本框按键验证 - 限制温度参数输入格式
        private void TemperatureTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 验证输入字符：只允许控制字符、数字、小数点、负号
            if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar) &&
                e.KeyChar != '.' && e.KeyChar != '-')
            {
                e.Handled = true;  // 拒绝无效字符输入
            }

            // 小数点验证：确保只输入一个小数点
            if (e.KeyChar == '.' && ((TextBox)sender).Text.IndexOf('.') > -1)
            {
                e.Handled = true;  // 已存在小数点，拒绝再次输入
            }

            // 负号验证：负号只能出现在字符串开头
            if (e.KeyChar == '-' && ((TextBox)sender).SelectionStart != 0)
            {
                e.Handled = true;  // 负号不在开头位置，拒绝输入
            }

            // 回车键处理：执行确认操作
            if (e.KeyChar == (char)Keys.Enter)
            {
                e.Handled = true;  // 阻止默认回车行为
                ProcessEnterKey(); // 调用自定义回车处理逻辑
                return;           // 提前返回
            }
        }

        // 时间文本框按键验证 - 限制时间参数输入格式
        private void TimeTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 验证输入字符：只允许控制字符、数字、小数点（不允许负号）
            if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar) && e.KeyChar != '.')
            {
                e.Handled = true;  // 拒绝无效字符输入
            }

            // 小数点验证：确保只输入一个小数点
            if (e.KeyChar == '.' && ((TextBox)sender).Text.IndexOf('.') > -1)
            {
                e.Handled = true;  // 已存在小数点，拒绝再次输入
            }

            // 回车键处理：执行确认操作
            if (e.KeyChar == (char)Keys.Enter)
            {
                e.Handled = true;  // 阻止默认回车行为
                ProcessEnterKey(); // 调用自定义回车处理逻辑
                return;           // 提前返回
            }
        }

        // 绑定验证事件方法 - 为温度和时间文本框批量绑定输入验证
        private void BindValidationEvents()
        {
            // 定义温度参数文本框数组（20个温度段设定值）
            TextBox[] temperatureTextBoxes = new TextBox[]
            {
        textBox133, textBox218, textBox221, textBox225, textBox234, textBox237,
        textBox278, textBox280, textBox279, textBox275, textBox261, textBox266,
        textBox270, textBox272, textBox271, textBox264, textBox256, textBox260,
        textBox257, textBox253
            };

            // 定义时间参数文本框数组（20个时间段设定值）
            TextBox[] timeTextBoxes = new TextBox[]
            {
        textBox99, textBox100, textBox220, textBox223, textBox228, textBox236,
        textBox277, textBox276, textBox274, textBox273, textBox269, textBox268,
        textBox267, textBox265, textBox263, textBox262, textBox255, textBox254,
        textBox252, textBox251
            };

            // 批量绑定温度文本框的按键验证事件
            foreach (TextBox textBox in temperatureTextBoxes)
            {
                textBox.KeyPress += TemperatureTextBox_KeyPress;  // 绑定温度输入验证
            }

            // 批量绑定时间文本框的按键验证事件
            foreach (TextBox textBox in timeTextBoxes)
            {
                textBox.KeyPress += TimeTextBox_KeyPress;  // 绑定时间输入验证
            }

            // 单独绑定循环次数文本框的按键验证
            textBox60.KeyPress += textBox60_KeyPress;  // 绑定特殊输入验证
        }

        // 循环次数文本框按键验证 - 严格限制只能输入数字
        private void textBox60_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 回车键处理：执行确认操作
            if (e.KeyChar == (char)Keys.Enter)
            {
                e.Handled = true;  // 阻止默认回车行为
                ProcessEnterKey(); // 调用自定义回车处理逻辑
                return;           // 提前返回
            }

            // 允许控制字符（退格、删除等）
            if (char.IsControl(e.KeyChar))
            {
                return;  // 允许控制字符通过
            }

            // 严格验证：只允许数字0-9，不允许小数点和其他字符
            if (e.KeyChar < '0' || e.KeyChar > '9')
            {
                e.Handled = true;  // 拒绝非数字字符输入
            }
        }

        // 处理回车键确认方法 - 统一处理文本框的回车确认逻辑
        private void ProcessEnterKey()
        {
            // 将焦点移动到下一个控件，实现Tab键的类似功能
            this.SelectNextControl(textBox60, true, true, true, true);

            // 预留扩展：可在此处添加其他回车确认逻辑
            // ValidateInput();        // 输入验证
            // SaveData();            // 数据保存  
            // buttonOK.PerformClick(); // 模拟确定按钮点击
        }
    }
}

